@codingame/monaco-vscode-chat-service-override 20.1.1 → 20.2.0

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

@@ -11,6 +11,9 @@ import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+/**
+ * Utility class to locate prompt files.
+ */
 export declare class PromptFilesLocator extends Disposable {
     private readonly fileService;
     private readonly configService;
@@ -20,6 +23,11 @@ export declare class PromptFilesLocator extends Disposable {
     private readonly userDataService;
     private readonly logService;
     constructor(fileService: IFileService, configService: IConfigurationService, workspaceService: IWorkspaceContextService, environmentService: IWorkbenchEnvironmentService, searchService: ISearchService, userDataService: IUserDataProfileService, logService: ILogService);
+    /**
+     * List all prompt files from the filesystem.
+     *
+     * @returns List of prompt files found in the workspace.
+     */
     listFiles(type: PromptsType, storage: TPromptsStorage, token: CancellationToken): Promise<readonly URI[]>;
     private listFilesInUserData;
     getCopilotInstructionsFiles(instructionFilePaths: Iterable<string>): Promise<URI[]>;
@@ -27,11 +35,42 @@ export declare class PromptFilesLocator extends Disposable {
         readonly event: Event<void>;
         dispose: () => void;
     };
+    /**
+     * Get all possible unambiguous prompt file source folders based on
+     * the current workspace folder structure.
+     *
+     * This method is currently primarily used by the `> Create Prompt`
+     * command that providers users with the list of destination folders
+     * for a newly created prompt file. Because such a list cannot contain
+     * paths that include `glob pattern` in them, we need to process config
+     * values and try to create a list of clear and unambiguous locations.
+     *
+     * @returns List of possible unambiguous prompt file folders.
+     */
     getConfigBasedSourceFolders(type: PromptsType): readonly URI[];
+    /**
+     * Finds all existent prompt files in the configured local source folders.
+     *
+     * @returns List of prompt files found in the local source folders.
+     */
     private listFilesInLocal;
     private getLocalParentFolders;
+    /**
+     * Converts locations defined in `settings` to absolute filesystem path URIs.
+     * This conversion is needed because locations in settings can be relative,
+     * hence we need to resolve them based on the current workspace folders.
+     */
     private toAbsoluteLocations;
+    /**
+     * Uses the file service to resolve the provided location and return either the file at the location of files in the directory.
+     */
     private resolveFilesAtLocation;
+    /**
+     * Uses the search service to find all files at the provided location
+     */
     private searchFilesInLocation;
 }
+/**
+ * Checks if the provided `pattern` could be a valid glob pattern.
+ */
 export declare function isValidGlob(pattern: string): boolean;

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.d.ts

@@ -19,6 +19,9 @@ export interface IRawToolContribution {
 }
 export interface IRawToolSetContribution {
     name: string;
+    /**
+     * @deprecated
+     */
     referenceName?: string;
     description: string;
     icon?: string;

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsParametersSchema.d.ts

@@ -1 +1,6 @@
+/**
+ * A schema for parametersSchema
+ * This is a subset of https://json-schema.org/draft-07/schema to capture what is actually supported by language models for tools, mainly, that they must be an object at the top level.
+ * Possibly it can be whittled down some more based on which attributes are supported by language models.
+ */
 export declare const toolsParametersSchemaSchemaId = "vscode://schemas/toolsParameters";

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

@@ -13,6 +13,11 @@ export interface IVoiceChatSessionOptions {
     readonly model?: IChatModel;
 }
 export interface IVoiceChatTextEvent extends ISpeechToTextEvent {
+    /**
+     * This property will be `true` when the text recognized
+     * so far only consists of agent prefixes (`@workspace`)
+     * and/or command prefixes (`@workspace /fix`).
+     */
     readonly waitingForInput?: boolean;
 }
 export interface IVoiceChatSession {

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

@@ -3,5 +3,11 @@ import { IVoiceChatSessionOptions, IVoiceChatSession } from "./voiceChatService.
 export declare const IVoiceChatService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IVoiceChatService>;
 export interface IVoiceChatService {
     readonly _serviceBrand: undefined;
+    /**
+    * Similar to `ISpeechService.createSpeechToTextSession`, but with
+    * support for agent prefixes and command prefixes. For example,
+    * if the user says "at workspace slash fix this problem", the result
+    * will be "@workspace /fix this problem".
+    */
     createVoiceChatSession(token: CancellationToken, options: IVoiceChatSessionOptions): Promise<IVoiceChatSession>;
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/media/terminalChatWidget.css

@@ -1,3 +1,8 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
 .monaco-workbench .terminal-inline-chat {
 	position: absolute;
 	left: 0;
@@ -5,6 +10,7 @@
 	z-index: 100;
 	height: auto !important;
 }
+
 .monaco-workbench .terminal-inline-chat .inline-chat {
 	margin-top: 0 !important;
 	color: inherit;
@@ -14,6 +20,7 @@
 	background: var(--vscode-inlineChat-background);
 	position: relative;
 	outline: none;
+
 	border-top-style: solid;
 	border-bottom-style: solid;
 	border-top-color: rgb(0, 122, 204);
@@ -21,34 +28,44 @@
 	border-top-width: 1px;
 	border-bottom-width: 1px;
 }
+
 .monaco-workbench .terminal-inline-chat .interactive-session {
 	margin: initial;
 }
+
 .monaco-workbench .terminal-inline-chat.hide {
 	visibility: hidden;
 }
+
 .monaco-workbench .terminal-inline-chat .chatMessageContent .value {
 	padding-top: 10px;
 }
+
 .monaco-workbench .terminal-inline-chat .inline-chat-input .monaco-editor-background {
+	/* Override the global panel rule for monaco backgrounds */
 	background-color: var(--vscode-inlineChatInput-background) !important;
 }
+
 @property --inline-chat-frame-progress {
 	syntax: '<percentage>';
 	initial-value: 0%;
 	inherits: false;
 }
+
 @keyframes shift {
 	0% {
 		--inline-chat-frame-progress: 0%;
 	}
+
 	50% {
 		--inline-chat-frame-progress: 100%;
 	}
+
 	100% {
 		--inline-chat-frame-progress: 0%;
 	}
 }
+
 .monaco-workbench .terminal-inline-chat.busy .inline-chat {
 	--inline-chat-frame-progress: 0%;
 	border-image: linear-gradient(90deg, var(--vscode-editorGutter-addedBackground) var(--inline-chat-frame-progress), var(--vscode-button-background)) 1;

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatController.d.ts

@@ -14,7 +14,15 @@ export declare class TerminalChatController extends Disposable implements ITermi
     private readonly _terminalService;
     static readonly ID = "terminal.chat";
     static get(instance: ITerminalInstance): TerminalChatController | null;
+    /**
+     * The chat widget for the controller, this is lazy as we don't want to instantiate it until
+     * both it's required and xterm is ready.
+     */
     private _terminalChatWidget;
+    /**
+     * The terminal chat widget for the controller, this will be undefined if xterm is not ready yet (ie. the
+     * terminal is still initializing). This wraps the inline chat widget.
+     */
     get terminalChatWidget(): TerminalChatWidget | undefined;
     private _lastResponseContent;
     get lastResponseContent(): string | undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chat/browser/terminalChatControllerHolder.d.ts

@@ -1,3 +1,7 @@
 import { TerminalChatController } from "./terminalChatController.js";
+/**
+ * The controller for the currently focused chat widget. This is used to track action context since 'active terminals'
+ * are only tracked for non-detached terminal instanecs.
+ */
 export declare let activeChatController: TerminalChatController | undefined;
 export declare function setActiveChatController(_activeChatController: TerminalChatController | undefined): void;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/bufferOutputPolling.d.ts

@@ -6,12 +6,16 @@ import { IToolInvocationContext } from "@codingame/monaco-vscode-api/vscode/vs/w
 import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import type { IMarker as IXtermMarker } from "@xterm/xterm";
 export declare enum PollingConsts {
-    MinNoDataEvents = 2,
+    MinNoDataEvents = 2,// Minimum number of no data checks before considering the terminal idle
     MinPollingDuration = 500,
-    FirstPollingMaxDuration = 20000,
-    ExtendedPollingMaxDuration = 120000,
+    FirstPollingMaxDuration = 20000,// 20 seconds
+    ExtendedPollingMaxDuration = 120000,// 2 minutes
     MaxPollingIntervalDuration = 2000
 }
+/**
+ * Waits for either polling to complete (terminal idle or timeout) or for the user to respond to a prompt.
+ * If polling completes first, the prompt is removed. If the prompt completes first and is accepted, polling continues.
+ */
 export declare function racePollingOrPrompt(pollFn: () => Promise<{
     terminalExecutionIdleBeforeTimeout: boolean;
     output: string;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/basicExecuteStrategy.d.ts

@@ -3,6 +3,28 @@ import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-a9da9
 import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+/**
+ * This strategy is used when shell integration is enabled, but rich command detection was not
+ * declared by the shell script. This is the large spectrum between rich command detection and no
+ * shell integration, here are some problems that are expected:
+ *
+ * - `133;C` command executed may not happen.
+ * - `633;E` comamnd line reporting will likely not happen, so the command line contained in the
+ *   execution start and end events will be of low confidence and chances are it will be wrong.
+ * - Execution tracking may be incorrect, particularly when `executeCommand` calls are overlapped,
+ *   such as Python activating the environment at the same time as Copilot executing a command. So
+ *   the end event for the execution may actually correspond to a different command.
+ *
+ * This strategy focuses on trying to get the most accurate output given these limitations and
+ * unknowns. Basically we cannot fully trust the extension APIs in this case, so polling of the data
+ * stream is used to detect idling, and we listen to the terminal's data stream instead of the
+ * execution's data stream.
+ *
+ * This is best effort with the goal being the output is accurate, though it may contain some
+ * content above and below the command output, such as prompts or even possibly other command
+ * output. We lean on the LLM to be able to differentiate the actual output from prompts and bad
+ * output when it's not ideal.
+ */
 export declare class BasicExecuteStrategy implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _commandDetection;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/executeStrategy.d.ts

@@ -4,6 +4,10 @@ import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/com
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 export interface ITerminalExecuteStrategy {
     readonly type: "rich" | "basic" | "none";
+    /**
+     * Executes a command line and gets a result designed to be passed directly to an LLM. The
+     * result will include information about the exit code.
+     */
     execute(commandLine: string, token: CancellationToken): Promise<ITerminalExecuteStrategyResult>;
 }
 export interface ITerminalExecuteStrategyResult {
@@ -13,4 +17,8 @@ export interface ITerminalExecuteStrategyResult {
     error?: string;
 }
 export declare function waitForIdle(onData: Event<unknown>, idleDurationMs: number): Promise<void>;
+/**
+ * Tracks the terminal for being idle on a prompt input. This must be called before `executeCommand`
+ * is called.
+ */
 export declare function trackIdleOnPrompt(instance: ITerminalInstance, idleDurationMs: number, store: DisposableStore): Promise<void>;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.d.ts

@@ -2,6 +2,12 @@ import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/b
 import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+/**
+ * This strategy is used when no shell integration is available. There are very few extension APIs
+ * available in this case. This uses similar strategies to the basic integration strategy, but
+ * with `sendText` instead of `shellIntegration.executeCommand` and relying on idle events instead
+ * of execution events.
+ */
 export declare class NoneExecuteStrategy implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _logService;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/richExecuteStrategy.d.ts

@@ -3,6 +3,13 @@ import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-a9da9
 import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
 import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+/**
+ * This strategy is used when the terminal has rich shell integration/command detection is
+ * available, meaning every sequence we rely upon should be exactly where we expect it to be. In
+ * particular (`633;`) `A, B, E, C, D` all happen in exactly that order. While things still could go
+ * wrong in this state, minimal verification is done in this mode since rich command detection is a
+ * strong signal that it's behaving correctly.
+ */
 export declare class RichExecuteStrategy implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _commandDetection;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/task/taskHelpers.d.ts

@@ -10,6 +10,19 @@ export declare function getTaskForTool(id: string | undefined, taskDefinition: {
     taskLabel?: string;
     taskType?: string;
 }, workspaceFolder: string, configurationService: IConfigurationService, taskService: ITaskService): Promise<Task | undefined>;
+/**
+ * Represents a configured task in the system.
+ *
+ * This interface is used to define tasks that can be executed within the workspace.
+ * It includes optional properties for identifying and describing the task.
+ *
+ * Properties:
+ * - `type`: (optional) The type of the task, which categorizes it (e.g., "build", "test").
+ * - `label`: (optional) A user-facing label for the task, typically used for display purposes.
+ * - `script`: (optional) A script associated with the task, if applicable.
+ * - `command`: (optional) A command associated with the task, if applicable.
+ *
+ */
 export interface IConfiguredTask {
     label?: string;
     type?: string;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/toolTerminalCreator.d.ts

@@ -12,6 +12,10 @@ export interface IToolTerminal {
 }
 export declare class ToolTerminalCreator {
     private readonly _terminalService;
+    /**
+     * The shell preference cached for the lifetime of the window. This allows skipping previous
+     * shell approaches that failed in previous runs to save time.
+     */
     private static _lastSuccessfulShell;
     constructor(_terminalService: ITerminalService);
     createTerminal(token: CancellationToken): Promise<IToolTerminal>;