@codingame/monaco-vscode-api 26.2.1 → 27.0.0

package/vscode/src/vs/platform/userInteraction/browser/userInteractionServiceImpl.js

@@ -0,0 +1,62 @@
+
+import { getWindow, ModifierKeyEmitter, trackFocus } from '../../../base/browser/dom.js';
+import '../../../base/common/observableInternal/index.js';
+import '../../instantiation/common/extensions.js';
+import '../../instantiation/common/instantiation.js';
+import { observableFromEvent } from '../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
+
+class UserInteractionService {
+    constructor() {
+        this._modifierObservables = ( new WeakMap());
+    }
+    readModifierKeyStatus(element, reader) {
+        const win = element instanceof Window ? element : getWindow(element);
+        let obs = this._modifierObservables.get(win);
+        if (!obs) {
+            const emitter = ModifierKeyEmitter.getInstance();
+            obs = observableFromEvent(this, emitter.event, () => ({
+                ctrlKey: emitter.keyStatus.ctrlKey,
+                shiftKey: emitter.keyStatus.shiftKey,
+                altKey: emitter.keyStatus.altKey,
+                metaKey: emitter.keyStatus.metaKey
+            }));
+            this._modifierObservables.set(win, obs);
+        }
+        return obs.read(reader);
+    }
+    createFocusTracker(element, store) {
+        const tracker = store.add(trackFocus(element));
+        const hasFocusWithin = el => {
+            if (el instanceof Window) {
+                return el.document.hasFocus();
+            }
+            const shadowRoot = el.getRootNode() instanceof ShadowRoot ? el.getRootNode() : null;
+            const activeElement = shadowRoot ? shadowRoot.activeElement : el.ownerDocument.activeElement;
+            return el.contains(activeElement);
+        };
+        const value = observableValue("isFocused", hasFocusWithin(element));
+        store.add(tracker.onDidFocus(() => value.set(true, undefined)));
+        store.add(tracker.onDidBlur(() => value.set(false, undefined)));
+        return value;
+    }
+    createHoverTracker(element, store) {
+        const value = observableValue("isHovered", false);
+        const onEnter = () => value.set(true, undefined);
+        const onLeave = () => value.set(false, undefined);
+        element.addEventListener("mouseenter", onEnter);
+        element.addEventListener("mouseleave", onLeave);
+        store.add({
+            dispose: () => {
+                element.removeEventListener("mouseenter", onEnter);
+                element.removeEventListener("mouseleave", onLeave);
+            }
+        });
+        return value;
+    }
+    createDomFocusTracker(element) {
+        return trackFocus(element);
+    }
+}
+
+export { UserInteractionService };

package/vscode/src/vs/platform/window/common/window.d.ts

@@ -266,6 +266,7 @@ export interface INativeWindowConfiguration extends IWindowConfiguration, Native
         definition: PolicyDefinition;
         value: PolicyValue;
     }>;
+    isSessionsWindow?: boolean;
 }
 /**
  * According to Electron docs: `scale := 1.2 ^ level`.

package/vscode/src/vs/platform/workspace/common/workspace.d.ts

@@ -99,10 +99,6 @@ export interface IWorkspace {
      * the location of the workspace configuration
      */
     readonly configuration?: URI | null;
-    /**
-     * Whether this workspace is an agent sessions workspace.
-     */
-    readonly isAgentSessionsWorkspace?: boolean;
 }
 export declare function isWorkspace(thing: unknown): thing is IWorkspace;
 export interface IWorkspaceFolderData {
@@ -132,18 +128,16 @@ export declare class Workspace implements IWorkspace {
     private _transient;
     private _configuration;
     private ignorePathCasing;
-    private _isAgentSessionsWorkspace?;
     private foldersMap;
     private _folders;
     get folders(): WorkspaceFolder[];
     set folders(folders: WorkspaceFolder[]);
-    constructor(_id: string, folders: WorkspaceFolder[], _transient: boolean, _configuration: URI | null, ignorePathCasing: (key: URI) => boolean, _isAgentSessionsWorkspace?: boolean | undefined);
+    constructor(_id: string, folders: WorkspaceFolder[], _transient: boolean, _configuration: URI | null, ignorePathCasing: (key: URI) => boolean);
     update(workspace: Workspace): void;
     get id(): string;
     get transient(): boolean;
     get configuration(): URI | null;
     set configuration(configuration: URI | null);
-    get isAgentSessionsWorkspace(): boolean | undefined;
     getFolder(resource: URI): IWorkspaceFolder | null;
     private updateFoldersMap;
     toJSON(): IWorkspace;

package/vscode/src/vs/platform/workspace/common/workspace.js

@@ -69,19 +69,11 @@ let Workspace$1 = class Workspace {
         this._folders = folders;
         this.updateFoldersMap();
     }
-    constructor(
-        _id,
-        folders,
-        _transient,
-        _configuration,
-        ignorePathCasing,
-        _isAgentSessionsWorkspace
-    ) {
+    constructor(_id, folders, _transient, _configuration, ignorePathCasing) {
         this._id = _id;
         this._transient = _transient;
         this._configuration = _configuration;
         this.ignorePathCasing = ignorePathCasing;
-        this._isAgentSessionsWorkspace = _isAgentSessionsWorkspace;
         this.foldersMap = TernarySearchTree.forUris(this.ignorePathCasing, () => true);
         this.folders = folders;
     }
@@ -90,7 +82,6 @@ let Workspace$1 = class Workspace {
         this._configuration = workspace.configuration;
         this._transient = workspace.transient;
         this.ignorePathCasing = workspace.ignorePathCasing;
-        this._isAgentSessionsWorkspace = workspace.isAgentSessionsWorkspace;
         this.folders = workspace.folders;
     }
     get id() {
@@ -105,9 +96,6 @@ let Workspace$1 = class Workspace {
     set configuration(configuration) {
         this._configuration = configuration;
     }
-    get isAgentSessionsWorkspace() {
-        return this._isAgentSessionsWorkspace;
-    }
     getFolder(resource) {
         if (!resource) {
             return null;
@@ -125,8 +113,7 @@ let Workspace$1 = class Workspace {
             id: this.id,
             folders: this.folders,
             transient: this.transient,
-            configuration: this.configuration,
-            isAgentSessionsWorkspace: this.isAgentSessionsWorkspace
+            configuration: this.configuration
         };
     }
 };
@@ -163,7 +150,7 @@ function toWorkspaceFolder(resource) {
 const WORKSPACE_EXTENSION = "code-workspace";
 const WORKSPACE_SUFFIX = `.${WORKSPACE_EXTENSION}`;
 const WORKSPACE_FILTER = [{
-    name: ( localize(2474, "Code Workspace")),
+    name: ( localize(2514, "Code Workspace")),
     extensions: [WORKSPACE_EXTENSION]
 }];
 const UNTITLED_WORKSPACE_NAME = "workspace.json";

package/vscode/src/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService.service.d.ts

@@ -0,0 +1,47 @@
+import { Event } from "../../../../base/common/event.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IRange } from "../../../../editor/common/core/range.js";
+import { IAgentFeedbackChangeEvent, IAgentFeedback, IAgentFeedbackNavigationBearing } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/sessions/contrib/agentFeedback/browser/agentFeedbackService";
+export declare const IAgentFeedbackService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAgentFeedbackService>;
+export interface IAgentFeedbackService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeFeedback: Event<IAgentFeedbackChangeEvent>;
+    readonly onDidChangeNavigation: Event<URI>;
+    /**
+    * Add a feedback item for the given session.
+    */
+    addFeedback(sessionResource: URI, resourceUri: URI, range: IRange, text: string): IAgentFeedback;
+    /**
+    * Remove a single feedback item.
+    */
+    removeFeedback(sessionResource: URI, feedbackId: string): void;
+    /**
+    * Get all feedback items for a session.
+    */
+    getFeedback(sessionResource: URI): readonly IAgentFeedback[];
+    /**
+    * Resolve the most recently updated session that has feedback for a given resource.
+    */
+    getMostRecentSessionForResource(resourceUri: URI): URI | undefined;
+    /**
+    * Set the navigation anchor to a specific feedback item, open its editor, and fire a navigation event.
+    */
+    revealFeedback(sessionResource: URI, feedbackId: string): Promise<void>;
+    /**
+    * Navigate to next/previous feedback item in a session.
+    */
+    getNextFeedback(sessionResource: URI, next: boolean): IAgentFeedback | undefined;
+    /**
+    * Get the current navigation bearings for a session.
+    */
+    getNavigationBearing(sessionResource: URI): IAgentFeedbackNavigationBearing;
+    /**
+    * Clear all feedback items for a session (e.g., after sending).
+    */
+    clearFeedback(sessionResource: URI): void;
+    /**
+    * Add a feedback item and then submit the feedback. Waits for the
+    * attachment to be updated in the chat widget before submitting.
+    */
+    addFeedbackAndSubmit(sessionResource: URI, resourceUri: URI, range: IRange, text: string): Promise<void>;
+}

package/vscode/src/vs/{workbench/services/layout/common/workbenchModeService.service.js → sessions/contrib/agentFeedback/browser/agentFeedbackService.service.js}

@@ -1,6 +1,6 @@
 
 import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
 
-const IWorkbenchModeService = ( createDecorator("workbenchModeService"));
+const IAgentFeedbackService = ( createDecorator("agentFeedbackService"));
 
-export { IWorkbenchModeService };
+export { IAgentFeedbackService };

package/vscode/src/vs/sessions/contrib/chat/browser/sessionTargetPicker.d.ts

@@ -0,0 +1,64 @@
+import { Event } from "../../../../base/common/event.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IActionWidgetService } from "../../../../platform/actionWidget/browser/actionWidget.service.js";
+import { AgentSessionProviders } from "../../../../workbench/contrib/chat/browser/agentSessions/agentSessions.js";
+import { IGitRepository } from "@codingame/monaco-vscode-extensions-service-override/vscode/vs/workbench/contrib/git/common/gitService";
+import { INewSession } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/sessions/contrib/chat/browser/newSession";
+/**
+ * A self-contained widget for selecting the session target (Local vs Cloud).
+ * Encapsulates state, events, and rendering. Can be placed anywhere in the view.
+ */
+export declare class SessionTargetPicker extends Disposable {
+    private _selectedTarget;
+    private _allowedTargets;
+    private readonly _onDidChangeTarget;
+    readonly onDidChangeTarget: Event<AgentSessionProviders>;
+    private readonly _renderDisposables;
+    private _container;
+    get selectedTarget(): AgentSessionProviders;
+    constructor(allowedTargets: AgentSessionProviders[], defaultTarget: AgentSessionProviders);
+    /**
+     * Renders the target radio (Local / Cloud) into the given container.
+     */
+    render(container: HTMLElement): void;
+    updateAllowedTargets(targets: AgentSessionProviders[]): void;
+    private _renderRadio;
+}
+export type IsolationMode = "worktree" | "workspace";
+/**
+ * A self-contained widget for selecting the isolation mode (Worktree vs Folder).
+ * Encapsulates state, events, and rendering. Can be placed anywhere in the view.
+ */
+export declare class IsolationModePicker extends Disposable {
+    private readonly actionWidgetService;
+    private _isolationMode;
+    private _newSession;
+    private _repository;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<IsolationMode>;
+    private readonly _renderDisposables;
+    private _slotElement;
+    private _triggerElement;
+    get isolationMode(): IsolationMode;
+    constructor(actionWidgetService: IActionWidgetService);
+    /**
+     * Sets the pending session that this picker writes to.
+     */
+    setNewSession(session: INewSession | undefined): void;
+    /**
+     * Sets the git repository. When undefined, worktree option is hidden
+     * and isolation mode falls back to 'workspace'.
+     */
+    setRepository(repository: IGitRepository | undefined): void;
+    /**
+     * Renders the isolation mode picker into the given container.
+     */
+    render(container: HTMLElement): void;
+    /**
+     * Shows or hides the picker.
+     */
+    setVisible(visible: boolean): void;
+    private _showPicker;
+    private _setMode;
+    private _updateTriggerLabel;
+}

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.service.d.ts

@@ -0,0 +1,37 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IActiveSessionItem } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService";
+import { ITaskEntry, TaskStorageTarget } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/sessions/contrib/chat/browser/sessionsConfigurationService";
+export interface ISessionsConfigurationService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Observable list of tasks with `inSessions: true`, automatically
+    * updated when the tasks.json file changes.
+    */
+    getSessionTasks(session: IActiveSessionItem): IObservable<readonly ITaskEntry[]>;
+    /**
+    * Returns tasks that do NOT have `inSessions: true` — used as
+    * suggestions in the "Add Run Action" picker.
+    */
+    getNonSessionTasks(session: IActiveSessionItem): Promise<readonly ITaskEntry[]>;
+    /**
+    * Sets `inSessions: true` on an existing task (identified by label),
+    * updating it in place in its tasks.json.
+    */
+    addTaskToSessions(task: ITaskEntry, session: IActiveSessionItem, target: TaskStorageTarget): Promise<void>;
+    /**
+    * Creates a new shell task with `inSessions: true` and writes it to
+    * the appropriate tasks.json (user or workspace).
+    */
+    createAndAddTask(command: string, session: IActiveSessionItem, target: TaskStorageTarget): Promise<ITaskEntry | undefined>;
+    /**
+    * Runs a task entry in a terminal, resolving the correct platform
+    * command and using the session worktree as cwd.
+    */
+    runTask(task: ITaskEntry, session: IActiveSessionItem): Promise<void>;
+    /**
+    * Observable label of the most recently run task for the given repository.
+    */
+    getLastRunTaskLabel(repository: URI | undefined): IObservable<string | undefined>;
+}
+export declare const ISessionsConfigurationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ISessionsConfigurationService>;

package/vscode/src/vs/sessions/contrib/chat/browser/sessionsConfigurationService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ISessionsConfigurationService = ( createDecorator("sessionsConfigurationService"));
+
+export { ISessionsConfigurationService };

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.service.d.ts

@@ -0,0 +1,47 @@
+import { IObservable } from "../../../../base/common/observable.js";
+import { URI } from "../../../../base/common/uri.js";
+import { AgentSessionProviders } from "../../../../workbench/contrib/chat/browser/agentSessions/agentSessions.js";
+import { ISessionOpenOptions } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsOpener";
+import { INewSession } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/sessions/contrib/chat/browser/newSession";
+import { IActiveSessionItem } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/sessions/contrib/sessions/browser/sessionsManagementService";
+export interface ISessionsManagementService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Observable for the currently active session.
+    */
+    readonly activeSession: IObservable<IActiveSessionItem | undefined>;
+    /**
+    * Returns the currently active session, if any.
+    */
+    getActiveSession(): IActiveSessionItem | undefined;
+    /**
+    * Select an existing session as the active session.
+    * Sets `isNewChatSession` context to false and opens the session.
+    */
+    openSession(sessionResource: URI, openOptions?: ISessionOpenOptions): Promise<void>;
+    /**
+    * Switch to the new-session view.
+    * No-op if the current session is already a new session.
+    */
+    openNewSessionView(): void;
+    /**
+    * Create a pending session object for the given target type.
+    * Local sessions collect options locally; remote sessions notify the extension.
+    */
+    createNewSessionForTarget(target: AgentSessionProviders, sessionResource: URI, defaultRepoUri?: URI): Promise<INewSession>;
+    /**
+    * Open a new session, apply options, and send the initial request.
+    * Looks up the session by resource URI and builds send options from it.
+    * When `openNewSessionView` is true, opens a new session view after sending
+    * instead of navigating to the newly created session.
+    */
+    sendRequestForNewSession(sessionResource: URI, options?: {
+        openNewSessionView?: boolean;
+    }): Promise<void>;
+    /**
+    * Commit files in a worktree and refresh the agent sessions model
+    * so the Changes view reflects the update.
+    */
+    commitWorktreeFiles(session: IActiveSessionItem, fileUris: URI[]): Promise<void>;
+}
+export declare const ISessionsManagementService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ISessionsManagementService>;

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsManagementService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const ISessionsManagementService = ( createDecorator("sessionsManagementService"));
+
+export { ISessionsManagementService };

package/vscode/src/vs/workbench/api/browser/statusBarExtensionPoint.js

@@ -23,48 +23,48 @@ const statusBarItemSchema = {
         id: {
             type: "string",
             markdownDescription: ( localize(
-                2567,
+                2607,
                 "The identifier of the status bar entry. Must be unique within the extension. The same value must be used when calling the `vscode.window.createStatusBarItem(id, ...)`-API"
             ))
         },
         name: {
             type: "string",
             description: ( localize(
-                2568,
+                2608,
                 "The name of the entry, like 'Python Language Indicator', 'Git Status' etc. Try to keep the length of the name short, yet descriptive enough that users can understand what the status bar item is about."
             ))
         },
         text: {
             type: "string",
             description: ( localize(
-                2569,
+                2609,
                 "The text to show for the entry. You can embed icons in the text by leveraging the `$(<name>)`-syntax, like 'Hello $(globe)!'"
             ))
         },
         tooltip: {
             type: "string",
-            description: ( localize(2570, "The tooltip text for the entry."))
+            description: ( localize(2610, "The tooltip text for the entry."))
         },
         command: {
             type: "string",
-            description: ( localize(2571, "The command to execute when the status bar entry is clicked."))
+            description: ( localize(2611, "The command to execute when the status bar entry is clicked."))
         },
         alignment: {
             type: "string",
             enum: ["left", "right"],
-            description: ( localize(2572, "The alignment of the status bar entry."))
+            description: ( localize(2612, "The alignment of the status bar entry."))
         },
         priority: {
             type: "number",
             description: ( localize(
-                2573,
+                2613,
                 "The priority of the status bar entry. Higher value means the item should be shown more to the left."
             ))
         },
         accessibilityInformation: {
             type: "object",
             description: ( localize(
-                2574,
+                2614,
                 "Defines the role and aria label to be used when the status bar entry is focused."
             )),
             required: ["label"],
@@ -72,14 +72,14 @@ const statusBarItemSchema = {
                 role: {
                     type: "string",
                     description: ( localize(
-                        2575,
+                        2615,
                         "The role of the status bar entry which defines how a screen reader interacts with it. More about aria roles can be found here https://w3c.github.io/aria/#widget_roles"
                     ))
                 },
                 label: {
                     type: "string",
                     description: ( localize(
-                        2576,
+                        2616,
                         "The aria label of the status bar entry. Defaults to the entry's text."
                     ))
                 }
@@ -88,7 +88,7 @@ const statusBarItemSchema = {
     }
 };
 const statusBarItemsSchema = {
-    description: ( localize(2577, "Contributes items to the status bar.")),
+    description: ( localize(2617, "Contributes items to the status bar.")),
     oneOf: [statusBarItemSchema, {
         type: "array",
         items: statusBarItemSchema
@@ -114,7 +114,7 @@ let StatusBarItemsExtensionPoint = class StatusBarItemsExtensionPoint {
                 } = entry;
                 for (const candidate of Iterable.wrap(value)) {
                     if (!isUserFriendlyStatusItemEntry(candidate)) {
-                        collector.error(( localize(2578, "Invalid status bar item contribution.")));
+                        collector.error(( localize(2618, "Invalid status bar item contribution.")));
                         continue;
                     }
                     const fullItemId = asStatusBarItemIdentifier(entry.description.identifier, candidate.id);