@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/automations/browser/automationInputCompletions.js

@@ -0,0 +1,216 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isAgentHostTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { AgentHostInputCompletionsBase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/agentHostInputCompletionsBase';
+import { registerChatInputReferenceDecorationType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatInputReferenceDecorations';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var AutomationInputCompletions_1;
+const ACCEPT_AUTOMATION_SKILL_COMPLETION_COMMAND = "sessions.automations.acceptSkillCompletion";
+const AUTOMATION_SKILL_DECORATION_TYPE = "automation-skill-reference";
+CommandsRegistry.registerCommand(ACCEPT_AUTOMATION_SKILL_COMPLETION_COMMAND, (_accessor, argument) => {
+    argument.handler.acceptCompletion(argument.range, argument.text);
+});
+let AutomationInputCompletions = AutomationInputCompletions_1 = class AutomationInputCompletions extends AgentHostInputCompletionsBase {
+    constructor(
+        editor,
+        languageFeaturesService,
+        chatSessionsService,
+        sessionsManagementService,
+        codeEditorService,
+        logService
+    ) {
+        super(languageFeaturesService, chatSessionsService);
+        this.editor = editor;
+        this.sessionsManagementService = sessionsManagementService;
+        this.logService = logService;
+        this.registration = this._register(( new MutableDisposable()));
+        this.restoreRequest = this._register(( new MutableDisposable()));
+        this.restoreScheduler = this._register(( new RunOnceScheduler(() => this.restorePersistedSkillReferences(), 200)));
+        this.references = [];
+        this.triggerCharacters = [];
+        this._register(
+            registerChatInputReferenceDecorationType(codeEditorService, AUTOMATION_SKILL_DECORATION_TYPE)
+        );
+        this._register(this.editor.onDidChangeModelContent(() => {
+            this.restoreRequest.clear();
+            this.updateDecorations();
+            this.restoreScheduler.schedule();
+        }));
+        let currentScheme;
+        this._register(autorun(reader => {
+            const session = this.sessionsManagementService.automationSession.read(reader);
+            const scheme = session ? getChatSessionType(session.resource) : undefined;
+            if (scheme === currentScheme) {
+                return;
+            }
+            currentScheme = scheme;
+            this.registration.clear();
+            this.restoreRequest.clear();
+            this.restoreScheduler.cancel();
+            this.triggerCharacters = [];
+            if (scheme && isAgentHostTarget(scheme)) {
+                void this.registerForScheme(scheme);
+            }
+        }));
+    }
+    async registerForScheme(scheme) {
+        const triggerCharacters = await this._chatSessionsService.getChatInputCompletionTriggerCharacters(scheme);
+        if (!triggerCharacters?.length) {
+            return;
+        }
+        const session = this.sessionsManagementService.automationSession.get();
+        const editorUri = this.editor.getModel()?.uri;
+        if (!session || getChatSessionType(session.resource) !== scheme || !editorUri) {
+            return;
+        }
+        this.registration.value = this._registerProvider({
+            scheme: editorUri.scheme,
+            hasAccessToAllModels: true
+        }, `automationInputCompletions[${scheme}]`, triggerCharacters, scheme);
+        this.triggerCharacters = triggerCharacters;
+        this.restorePersistedSkillReferences();
+    }
+    _resolveContext(model, scheme) {
+        const session = this.sessionsManagementService.automationSession.get();
+        if (model !== this.editor.getModel() || !session || getChatSessionType(session.resource) !== scheme) {
+            return undefined;
+        }
+        return {
+            sessionResource: session.resource,
+            context: undefined
+        };
+    }
+    _buildItem(position, item) {
+        if (item.attachment.kind !== "skill" && !(item.attachment.kind === "command" && item.attachment.isSkill)) {
+            return undefined;
+        }
+        const ranges = AutomationInputCompletions_1.computeRange(position, item);
+        const referenceText = item.insertText.trimEnd();
+        return {
+            label: {
+                label: item.label ?? item.insertText,
+                description: item.attachment.description
+            },
+            insertText: item.insertText,
+            filterText: item.insertText,
+            range: ranges,
+            documentation: item.attachment.description,
+            kind: CompletionItemKind.Text,
+            command: {
+                id: ACCEPT_AUTOMATION_SKILL_COMPLETION_COMMAND,
+                title: "",
+                arguments: [{
+                    handler: this,
+                    range: ranges.replace.setEndPosition(
+                        ranges.replace.startLineNumber,
+                        ranges.replace.startColumn + referenceText.length
+                    ),
+                    text: referenceText
+                }]
+            }
+        };
+    }
+    acceptCompletion(range, text) {
+        this.updateDecorations({
+            range,
+            text
+        });
+    }
+    restorePersistedSkillReferences() {
+        const session = this.sessionsManagementService.automationSession.get();
+        const model = this.editor.getModel();
+        if (!session || !model || this.triggerCharacters.length === 0) {
+            return;
+        }
+        const value = model.getValue();
+        const tokens = [...value.matchAll(/\S+/g)].map(match => ({
+            text: match[0],
+            start: match.index,
+            end: match.index + match[0].length
+        })).filter(token => this.triggerCharacters.includes(token.text[0]));
+        if (tokens.length === 0) {
+            return;
+        }
+        this.restoreRequest.clear();
+        const request = ( new CancellationTokenSource());
+        this.restoreRequest.value = toDisposable(() => request.dispose(true));
+        void (async () => {
+            const distinctTokens = [...( ( new Map(tokens.map(token => [token.text, token]))).values())];
+            const skillResults = await Promise.all(distinctTokens.map(async token => {
+                const result = await this._chatSessionsService.provideChatInputCompletions(session.resource, {
+                    text: value,
+                    offset: token.end
+                }, request.token);
+                return [token.text, result?.items.some(
+                    item => (item.attachment.kind === "skill" || (item.attachment.kind === "command" && item.attachment.isSkill)) && item.insertText.trimEnd() === token.text
+                ) === true];
+            }));
+            if (request.token.isCancellationRequested) {
+                return;
+            }
+            const skillTexts = ( new Set(skillResults.filter(([, isSkill]) => isSkill).map(([text]) => text)));
+            const restored = tokens.flatMap(token => ( skillTexts.has(token.text)) ? [{
+                range: Range.fromPositions(model.getPositionAt(token.start), model.getPositionAt(token.end)),
+                text: token.text
+            }] : []);
+            if (session === this.sessionsManagementService.automationSession.get() && model === this.editor.getModel() && model.getValue() === value) {
+                this.updateDecorations(undefined, restored, true);
+            }
+        })().catch(error => {
+            if (!request.token.isCancellationRequested) {
+                this.logService.error(
+                    "[AutomationInputCompletions] Failed to restore persisted skill references",
+                    error
+                );
+            }
+        });
+    }
+    updateDecorations(accepted, restored = [], replace = false) {
+        const model = this.editor.getModel();
+        if (!model) {
+            this.references = [];
+            return;
+        }
+        const references = replace ? [] : this.references.flatMap(reference => {
+            const range = model.getDecorationRange(reference.decorationId);
+            return range && model.getValueInRange(range) === reference.text ? [{
+                range,
+                text: reference.text
+            }] : [];
+        });
+        if (accepted) {
+            references.push(accepted);
+        }
+        for (const reference of restored) {
+            if (!( references.some(
+                existing => existing.text === reference.text && Range.equalsRange(existing.range, reference.range)
+            ))) {
+                references.push(reference);
+            }
+        }
+        const decorationIds = this.editor.setDecorationsByType("chat", AUTOMATION_SKILL_DECORATION_TYPE, references.map(reference => ({
+            range: reference.range
+        })));
+        this.references = decorationIds.map((decorationId, index) => ({
+            decorationId,
+            text: references[index].text
+        }));
+    }
+};
+AutomationInputCompletions = AutomationInputCompletions_1 = ( __decorate([( __param(1, ILanguageFeaturesService)), ( __param(2, IChatSessionsService)), ( __param(3, ISessionsManagementService)), ( __param(4, ICodeEditorService)), ( __param(5, ILogService))], AutomationInputCompletions));
+
+export { AutomationInputCompletions };

package/vscode/src/vs/sessions/contrib/automations/browser/automationLeaderElection.d.ts

@@ -0,0 +1,37 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+export declare const DEFAULT_HEARTBEAT_INTERVAL_MS = 30000;
+export declare const DEFAULT_STALE_AFTER_MS = 90000;
+export interface IAutomationLeaderElectionOptions {
+    readonly heartbeatIntervalMs?: number;
+    readonly staleAfterMs?: number;
+    readonly now?: () => number;
+    readonly instanceId?: string;
+}
+export declare class AutomationLeaderElection extends Disposable {
+    private readonly storageService;
+    private readonly logService;
+    private readonly _isLeader;
+    readonly isLeader: IObservable<boolean>;
+    private readonly _instanceId;
+    private readonly _heartbeatIntervalMs;
+    private readonly _staleAfterMs;
+    private readonly _now;
+    private readonly _timer;
+    constructor(storageService: IStorageService, logService: ILogService, options?: IAutomationLeaderElectionOptions);
+    get instanceId(): string;
+    /** Test-only: drive the evaluation cycle synchronously. */
+    evaluateForTesting(): void;
+    private evaluate;
+    private readLeader;
+    /** Returns true if the write succeeded, false if storage threw. */
+    private writeLeader;
+    private releaseIfLeader;
+}
+export interface IAutomationLeaderElection extends IDisposable {
+    readonly isLeader: IObservable<boolean>;
+    readonly instanceId: string;
+    evaluateForTesting(): void;
+}

package/vscode/src/vs/sessions/contrib/automations/browser/automationLeaderElection.js

@@ -0,0 +1,126 @@
+
+import { IntervalTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const LEADER_KEY = "chat.automations.leader";
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
+const DEFAULT_STALE_AFTER_MS = 90_000;
+class AutomationLeaderElection extends Disposable {
+    constructor(storageService, logService, options = {}) {
+        super();
+        this.storageService = storageService;
+        this.logService = logService;
+        this._timer = this._register(( new IntervalTimer()));
+        this._instanceId = options.instanceId ?? generateUuid();
+        this._heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+        this._staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+        this._now = options.now ?? Date.now;
+        this._isLeader = observableValue(this, false);
+        this.isLeader = this._isLeader;
+        this._register(toDisposable(() => this.releaseIfLeader()));
+        this.evaluate();
+        this._timer.cancelAndSet(() => this.evaluate(), this._heartbeatIntervalMs);
+    }
+    get instanceId() {
+        return this._instanceId;
+    }
+    evaluateForTesting() {
+        this.evaluate();
+    }
+    evaluate() {
+        const now = this._now();
+        const current = this.readLeader();
+        const claimable = !current || current.instanceId === this._instanceId || current.instanceId === "" || (now - current.heartbeatAt) > this._staleAfterMs;
+        if (!claimable) {
+            if (this._isLeader.get()) {
+                this.logService.info(
+                    `[AutomationLeaderElection] window ${this._instanceId} stood down for ${current.instanceId}.`
+                );
+            }
+            this._isLeader.set(false, undefined);
+            return;
+        }
+        const nonce = generateUuid();
+        const writeOk = this.writeLeader({
+            instanceId: this._instanceId,
+            heartbeatAt: now,
+            nonce
+        });
+        if (!writeOk) {
+            this._isLeader.set(false, undefined);
+            return;
+        }
+        const verify = this.readLeader();
+        if (verify?.instanceId === this._instanceId && verify.nonce === nonce) {
+            if (!this._isLeader.get()) {
+                this.logService.info(
+                    `[AutomationLeaderElection] window ${this._instanceId} claimed leader slot.`
+                );
+            }
+            this._isLeader.set(true, undefined);
+        } else {
+            if (this._isLeader.get()) {
+                this.logService.info(
+                    `[AutomationLeaderElection] window ${this._instanceId} lost leader race to ${verify?.instanceId ?? "<none>"}.`
+                );
+            }
+            this._isLeader.set(false, undefined);
+        }
+    }
+    readLeader() {
+        let raw;
+        try {
+            raw = this.storageService.get(LEADER_KEY, StorageScope.APPLICATION);
+        } catch (err) {
+            this.logService.warn("[AutomationLeaderElection] storage read failed", err);
+            return undefined;
+        }
+        if (!raw) {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed?.instanceId !== "string" || typeof parsed?.heartbeatAt !== "number") {
+                return undefined;
+            }
+            return {
+                instanceId: parsed.instanceId,
+                heartbeatAt: parsed.heartbeatAt,
+                nonce: typeof parsed.nonce === "string" ? parsed.nonce : ""
+            };
+        } catch {
+            return undefined;
+        }
+    }
+    writeLeader(record) {
+        try {
+            this.storageService.store(
+                LEADER_KEY,
+                JSON.stringify(record),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+            return true;
+        } catch (err) {
+            this.logService.warn("[AutomationLeaderElection] storage write failed", err);
+            return false;
+        }
+    }
+    releaseIfLeader() {
+        const current = this.readLeader();
+        if (current?.instanceId !== this._instanceId) {
+            return;
+        }
+        this.writeLeader({
+            instanceId: "",
+            heartbeatAt: 0,
+            nonce: ""
+        });
+    }
+}
+
+export { AutomationLeaderElection, DEFAULT_HEARTBEAT_INTERVAL_MS, DEFAULT_STALE_AFTER_MS };

package/vscode/src/vs/sessions/contrib/automations/browser/automationRunner.d.ts

@@ -0,0 +1,21 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { AutomationRunTrigger, IAutomationDescriptor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation";
+import { IAutomationRunOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner";
+import { IAutomationRunner } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner.service";
+import { IAutomationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+/** Sessions-layer runner. Never throws; failures are recorded on the run row. */
+export declare class AutomationRunner implements IAutomationRunner {
+    private readonly automationService;
+    private readonly sessionsManagementService;
+    private readonly logService;
+    private readonly notificationService;
+    readonly _serviceBrand: undefined;
+    constructor(automationService: IAutomationService, sessionsManagementService: ISessionsManagementService, logService: ILogService, notificationService: INotificationService);
+    runOnce(automation: IAutomationDescriptor, trigger: AutomationRunTrigger, leaderWindowId: number, token?: CancellationToken): IAutomationRunOperation;
+    private _runOnce;
+    private _runOnceInner;
+    private _markCancelled;
+}