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

package/vscode/src/vs/sessions/contrib/search/browser/searchEditorEmptyState.contribution.js

@@ -0,0 +1,57 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as searchEditorEmptyState from './media/searchEditorEmptyState.css';
+import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { registerEditorContribution, EditorContributionInstantiation } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { observableCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/observableCodeEditor';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SearchEditorScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/searchEditor/browser/constants';
+import { renderSessionsEmptyState } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/sessionsEmptyState';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+
+registerCss(searchEditorEmptyState, 1);
+class SearchEditorEmptyStateContribution extends Disposable {
+    static {
+        this.ID = "sessions.searchEditor.emptyState";
+    }
+    constructor(editor) {
+        super();
+        const editorObservable = observableCodeEditor(editor);
+        this._register(autorun(reader => {
+            const model = editorObservable.model.read(reader);
+            if (model?.uri.scheme !== SearchEditorScheme) {
+                return;
+            }
+            editorObservable.versionId.read(reader);
+            if (model.getValueLength() !== 0) {
+                return;
+            }
+            const container = $(".sessions-search-empty-state");
+            renderSessionsEmptyState(container, ( localize(4465, "Search")), ( localize(4466, "Search for text in your files")));
+            reader.store.add(editorObservable.createOverlayWidget({
+                domNode: container,
+                position: constObservable(null),
+                minContentWidthInPx: constObservable(0),
+                allowEditorOverflow: false
+            }));
+            reader.store.add(autorun(reader => {
+                const {
+                    width,
+                    height
+                } = editorObservable.layoutInfo.read(reader);
+                container.style.width = `${width}px`;
+                container.style.height = `${height}px`;
+            }));
+        }));
+    }
+}
+registerEditorContribution(
+    SearchEditorEmptyStateContribution.ID,
+    SearchEditorEmptyStateContribution,
+    EditorContributionInstantiation.AfterFirstRender
+);
+
+export { SearchEditorEmptyStateContribution };

package/vscode/src/vs/sessions/contrib/sessions/browser/blockedSessionsCIFixModel.d.ts

@@ -0,0 +1,39 @@
+import { Disposable } 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 { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IGitHubService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service";
+import { ISessionCIFixModel, ISessionCIFixState } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList";
+/**
+ * Backs the per-session "Fix CI" row shown in the blocked-sessions dropdown for
+ * sessions whose pull request has failing CI checks. Exposes a reactive summary
+ * of the failing/pending check counts and, on demand, submits the `fix-ci`
+ * prompt to the session's chat **in the background** — the session starts
+ * working without being opened or made visible.
+ *
+ * While a fix is being submitted the session is reported via
+ * {@link hiddenSessions} so the blocked-sessions list can drop it immediately;
+ * by the time the submit resolves the session is in progress and so is no longer
+ * blocked, keeping it out of the list without a flicker.
+ */
+export declare class BlockedSessionsCIFixModel extends Disposable implements ISessionCIFixModel {
+    private readonly _gitHubService;
+    private readonly _chatService;
+    private readonly _logService;
+    /** Cached CI-state observables, keyed by session, to keep references stable and GC-friendly. */
+    private readonly _states;
+    /**
+     * Session ids whose fix-CI submission is in flight. Doubles as the guard that
+     * stops repeated clicks submitting duplicate prompts, and as the set the
+     * blocked-sessions indicator hides while the background work runs.
+     */
+    private readonly _hiddenSessions;
+    readonly hiddenSessions: IObservable<ReadonlySet<string>>;
+    constructor(_gitHubService: IGitHubService, _chatService: IChatService, _logService: ILogService);
+    getCIFix(session: ISession): IObservable<ISessionCIFixState | undefined>;
+    fixCI(session: ISession): void;
+    private _fixCI;
+    private _acquireCIModel;
+    private _setHidden;
+}

package/vscode/src/vs/sessions/contrib/sessions/browser/blockedSessionsCIFixModel.js

@@ -0,0 +1,155 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ChatSendResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { getFailedChecks, buildFixCIPrompt } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/checksActions';
+import { IGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service';
+import { GitHubCheckStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/types';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+let BlockedSessionsCIFixModel = class BlockedSessionsCIFixModel extends Disposable {
+    constructor(_gitHubService, _chatService, _logService) {
+        super();
+        this._gitHubService = _gitHubService;
+        this._chatService = _chatService;
+        this._logService = _logService;
+        this._states = ( new WeakMap());
+        this._hiddenSessions = observableValue(this, ( new Set()));
+        this.hiddenSessions = this._hiddenSessions;
+    }
+    getCIFix(session) {
+        let obs = this._states.get(session);
+        if (!obs) {
+            obs = derived(this, reader => {
+                const gitHubInfo = session.workspace.read(reader)?.folders[0]?.gitRepository?.gitHubInfo.read(reader);
+                if (!gitHubInfo?.pullRequest) {
+                    return undefined;
+                }
+                const prRef = reader.delayedStore.add(
+                    this._gitHubService.createPullRequestModelReference(gitHubInfo.owner, gitHubInfo.repo, gitHubInfo.pullRequest.number)
+                );
+                const livePR = prRef.object.pullRequest.read(reader);
+                if (!livePR) {
+                    return undefined;
+                }
+                const ciRef = reader.delayedStore.add(this._gitHubService.createPullRequestCIModelReference(
+                    gitHubInfo.owner,
+                    gitHubInfo.repo,
+                    gitHubInfo.pullRequest.number,
+                    livePR.headSha
+                ));
+                const ciModel = ciRef.object;
+                if (ciModel.fixRequested.read(reader)) {
+                    return undefined;
+                }
+                const checks = ciModel.checks.read(reader);
+                const failed = getFailedChecks(checks).length;
+                if (failed === 0) {
+                    return undefined;
+                }
+                const completed = checks.filter(check => check.status === GitHubCheckStatus.Completed).length;
+                const pending = checks.length - completed;
+                return {
+                    failed,
+                    pending
+                };
+            });
+            this._states.set(session, obs);
+        }
+        return obs;
+    }
+    fixCI(session) {
+        if (( this._hiddenSessions.get().has(session.sessionId))) {
+            return;
+        }
+        this._setHidden(session.sessionId, true);
+        this._fixCI(session).catch(
+            err => this._logService.error("[BlockedSessionsCIFixModel] Failed to fix CI checks", err)
+        ).finally(() => this._setHidden(session.sessionId, false));
+    }
+    async _fixCI(session) {
+        const store = ( new DisposableStore());
+        try {
+            const ciModel = this._acquireCIModel(session, store);
+            if (!ciModel) {
+                return;
+            }
+            const prompt = await buildFixCIPrompt(ciModel);
+            if (!prompt) {
+                return;
+            }
+            const ref = await this._chatService.acquireOrLoadSession(
+                session.resource,
+                ChatAgentLocation.Chat,
+                CancellationToken.None,
+                "BlockedSessionsCIFix"
+            );
+            if (!ref) {
+                this._logService.error(
+                    "[BlockedSessionsCIFixModel] Cannot fix CI checks: failed to load session",
+                    ( session.resource.toString())
+                );
+                return;
+            }
+            try {
+                let result = await this._chatService.sendRequest(session.resource, prompt, {
+                    agentIdSilent: session.resource.scheme
+                });
+                if (ChatSendResult.isQueued(result)) {
+                    result = await result.deferred;
+                }
+                if (ChatSendResult.isSent(result)) {
+                    ciModel.markFixRequested();
+                } else if (ChatSendResult.isRejected(result)) {
+                    this._logService.error("[BlockedSessionsCIFixModel] Fix CI request rejected", result.reason);
+                }
+            } finally {
+                ref.dispose();
+            }
+        } finally {
+            store.dispose();
+        }
+    }
+    _acquireCIModel(session, store) {
+        const gitHubInfo = session.workspace.get()?.folders[0]?.gitRepository?.gitHubInfo.get();
+        if (!gitHubInfo?.pullRequest) {
+            return undefined;
+        }
+        const prRef = store.add(
+            this._gitHubService.createPullRequestModelReference(gitHubInfo.owner, gitHubInfo.repo, gitHubInfo.pullRequest.number)
+        );
+        const livePR = prRef.object.pullRequest.get();
+        if (!livePR) {
+            return undefined;
+        }
+        const ciRef = store.add(this._gitHubService.createPullRequestCIModelReference(
+            gitHubInfo.owner,
+            gitHubInfo.repo,
+            gitHubInfo.pullRequest.number,
+            livePR.headSha
+        ));
+        return ciRef.object;
+    }
+    _setHidden(sessionId, hidden) {
+        const current = this._hiddenSessions.get();
+        if (( current.has(sessionId)) === hidden) {
+            return;
+        }
+        const next = ( new Set(current));
+        if (hidden) {
+            next.add(sessionId);
+        } else {
+            next.delete(sessionId);
+        }
+        this._hiddenSessions.set(next, undefined);
+    }
+};
+BlockedSessionsCIFixModel = ( __decorate([( __param(0, IGitHubService)), ( __param(1, IChatService)), ( __param(2, ILogService))], BlockedSessionsCIFixModel));
+
+export { BlockedSessionsCIFixModel };

package/vscode/src/vs/sessions/contrib/sessions/browser/blockedSessionsIndicatorModel.d.ts

@@ -0,0 +1,117 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { AgentSessionApprovalModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionApprovalModel";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { BlockedSessions, IBlockedSession } from "../../blockedSessions/browser/blockedSessions.js";
+import { BlockedSessionsCIFixModel } from "./blockedSessionsCIFixModel.js";
+import { IApprovedSession } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList";
+/**
+ * The specific reason a homogeneous set of blocked sessions needs attention,
+ * used to render a more helpful requires-input message. `undefined` (a mix of
+ * reasons, or an indeterminate one) falls back to the generic message.
+ */
+export declare enum RequiresInputKind {
+    /** All sessions are waiting to run a terminal command. */
+    TerminalApproval = 0,
+    /** All sessions are asking the user a question. */
+    Question = 1,
+    /** All sessions have failing CI checks. */
+    FailingCI = 2
+}
+/**
+ * Model behind the sessions title bar's "N sessions require input" indicator.
+ *
+ * It refines the raw {@link BlockedSessions} set into what the title bar should
+ * actually surface: visible and explicitly ignored occurrences are acknowledged,
+ * approvals are dismissed optimistically, and later occurrences surface again.
+ *
+ * Blink detection keys off blocked occurrences, so navigation can acknowledge a
+ * block but never creates one.
+ *
+ * The DOM rendering of the indicator lives in the title bar widget; this class is
+ * DOM-free so it can be unit tested in isolation. It is owned by the title bar
+ * *contribution* rather than the widget, because the command center rebuilds its
+ * action view items (and so the widget) whenever its context keys change — e.g.
+ * when the new-session view opens — and acknowledgements must survive that.
+ */
+export declare class BlockedSessionsIndicatorModel extends Disposable {
+    private readonly _sessionsService;
+    private readonly _logService;
+    /** Computes the raw set of blocked sessions (needs input / failing CI). */
+    private readonly _blockedSessionsModel;
+    /** Tracks pending tool approvals per chat; distinguishes terminal vs question. */
+    private readonly _approvalModel;
+    /** The approval model, shared with the dropdown list so both agree on each session's pending action. */
+    get approvalModel(): AgentSessionApprovalModel;
+    /** Drives the per-session "Fix CI" row; shared with the dropdown list. */
+    private readonly _ciFixModel;
+    /** The CI-fix model, shared with the dropdown list so the fix action and the hide-while-fixing agree. */
+    get ciFixModel(): BlockedSessionsCIFixModel;
+    /** Current blocked occurrences the user has already acknowledged, keyed by session id. */
+    private readonly _ignoredBlockOccurrences;
+    /**
+     * Blocked sessions that are not visible, ignored, being fixed, or already approved.
+     * Visible blocked occurrences stay acknowledged after the user navigates away.
+     */
+    readonly blockedSessions: IObservable<readonly IBlockedSession[]>;
+    /**
+     * The homogeneous reason the blocked sessions need attention (all terminal
+     * approvals, all failing CI, etc.), or `undefined` when they are a mix — which
+     * drives whether a specific or the generic requires-input message is shown.
+     */
+    readonly requiresInputKind: IObservable<RequiresInputKind | undefined>;
+    /**
+     * Latest blocked occurrence per session, independent of visibility. Used so the
+     * attention blink only fires for a genuinely new input request or CI failure.
+     */
+    private _lastBlockedOccurrences;
+    /**
+     * Not-yet-visible blocked occurrences whose attention blink has not played yet.
+     */
+    private readonly _pendingBlinkOccurrences;
+    private readonly _onDidRequestBlink;
+    /**
+     * Fires when a genuinely new, not-yet-visible session becomes blocked and the
+     * indicator should play its attention blink. Consumers should re-render and
+     * call {@link consumePendingBlink}.
+     */
+    readonly onDidRequestBlink: Event<void>;
+    constructor(approvalModel: AgentSessionApprovalModel | undefined, blockedSessions: BlockedSessions | undefined, ciFixModel: BlockedSessionsCIFixModel | undefined, _sessionsService: ISessionsService, instantiationService: IInstantiationService, productService: IProductService, _logService: ILogService);
+    /**
+     * Whether a fresh attention blink is pending. Returns `true` only when a session
+     * queued as newly blocked is still in the surfaced (visible-filtered) blocked set,
+     * so a blink queued while the pill was suppressed can't fire for a session that has
+     * since become visible or unblocked. The pending queue is cleared as it is read so
+     * a subsequent render won't replay the animation.
+     */
+    consumePendingBlink(): boolean;
+    /** Ignore this session's current blocked occurrence. */
+    ignoreSession(session: ISession): void;
+    /** Ignore every blocked occurrence currently surfaced by the indicator. */
+    ignoreAllSessions(): void;
+    /**
+     * Remember that the user allowed this exact approval so the session drops out of
+     * the blocked set immediately.
+     */
+    dismissApproval(approved: IApprovedSession): void;
+    /**
+     * Build the requires-input pill label. A homogeneous set of blocked sessions
+     * gets a specific, more actionable message; a mix (or an unclassified session)
+     * falls back to the generic "N sessions require input".
+     */
+    getRequiresInputLabel(count: number, kind: RequiresInputKind | undefined): string;
+    private _ignoreOccurrence;
+    private _isBlockIgnored;
+    private _getBlockOccurrenceId;
+    private _approvalOccurrenceId;
+    /**
+     * Classify a single blocked session into a specific requires-input kind, or
+     * `undefined` when it can't be classified (which forces the generic message).
+     */
+    private _kindOf;
+}