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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-chat-service-override",
-  "version": "20.1.1",
+  "version": "20.2.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - chat service-override",
   "keywords": [],
@@ -15,41 +15,41 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common": "20.1.1",
-    "@codingame/monaco-vscode-0af61f78-dfc5-57ba-8d32-66268c8de38d-common": "20.1.1",
-    "@codingame/monaco-vscode-1021b67c-93e5-5c78-a270-cbdb2574d980-common": "20.1.1",
-    "@codingame/monaco-vscode-262ed59d-4f76-57cd-9e9f-1877f26ae049-common": "20.1.1",
-    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "20.1.1",
-    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.1.1",
-    "@codingame/monaco-vscode-615ce609-8555-545a-a549-47bd9f80e9f8-common": "20.1.1",
-    "@codingame/monaco-vscode-64322fa2-7385-5f46-935b-8f243d98004b-common": "20.1.1",
-    "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common": "20.1.1",
-    "@codingame/monaco-vscode-6883db80-c313-54eb-8fbc-5872c56b0326-common": "20.1.1",
-    "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common": "20.1.1",
-    "@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common": "20.1.1",
-    "@codingame/monaco-vscode-85f7fb0f-70f5-5a5e-831b-15c743a8bd11-common": "20.1.1",
-    "@codingame/monaco-vscode-88141f48-1af9-57ef-a278-f4b2ff6128fa-common": "20.1.1",
-    "@codingame/monaco-vscode-8c844347-a703-5de1-9eeb-5e0c7f503a58-common": "20.1.1",
-    "@codingame/monaco-vscode-9ed6fe06-a052-57c2-a234-5d9b94d2e7e0-common": "20.1.1",
-    "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common": "20.1.1",
-    "@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common": "20.1.1",
-    "@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common": "20.1.1",
-    "@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common": "20.1.1",
-    "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common": "20.1.1",
-    "@codingame/monaco-vscode-ac93482b-2178-52df-a200-ba0d1a4963fb-common": "20.1.1",
-    "@codingame/monaco-vscode-api": "20.1.1",
-    "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common": "20.1.1",
-    "@codingame/monaco-vscode-bb83fe45-f4c7-5673-b9f1-5c409a63f19c-common": "20.1.1",
-    "@codingame/monaco-vscode-bc8c28cd-7a80-54a9-af1a-e6b1e7a7f34a-common": "20.1.1",
-    "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common": "20.1.1",
-    "@codingame/monaco-vscode-d0569cfb-4706-5ad6-b0b0-5115ad8685db-common": "20.1.1",
-    "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common": "20.1.1",
-    "@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common": "20.1.1",
-    "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common": "20.1.1",
-    "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common": "20.1.1",
-    "@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common": "20.1.1",
-    "@codingame/monaco-vscode-f1bbc6d3-6129-583c-a2ba-c80b832993d2-common": "20.1.1",
-    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.1.1"
+    "@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common": "20.2.0",
+    "@codingame/monaco-vscode-0af61f78-dfc5-57ba-8d32-66268c8de38d-common": "20.2.0",
+    "@codingame/monaco-vscode-1021b67c-93e5-5c78-a270-cbdb2574d980-common": "20.2.0",
+    "@codingame/monaco-vscode-262ed59d-4f76-57cd-9e9f-1877f26ae049-common": "20.2.0",
+    "@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common": "20.2.0",
+    "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common": "20.2.0",
+    "@codingame/monaco-vscode-615ce609-8555-545a-a549-47bd9f80e9f8-common": "20.2.0",
+    "@codingame/monaco-vscode-64322fa2-7385-5f46-935b-8f243d98004b-common": "20.2.0",
+    "@codingame/monaco-vscode-670aae94-7f88-54d7-90ea-6fcbef423557-common": "20.2.0",
+    "@codingame/monaco-vscode-6883db80-c313-54eb-8fbc-5872c56b0326-common": "20.2.0",
+    "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common": "20.2.0",
+    "@codingame/monaco-vscode-72a1b7d3-3f58-5545-9b7e-f579bd003081-common": "20.2.0",
+    "@codingame/monaco-vscode-85f7fb0f-70f5-5a5e-831b-15c743a8bd11-common": "20.2.0",
+    "@codingame/monaco-vscode-88141f48-1af9-57ef-a278-f4b2ff6128fa-common": "20.2.0",
+    "@codingame/monaco-vscode-8c844347-a703-5de1-9eeb-5e0c7f503a58-common": "20.2.0",
+    "@codingame/monaco-vscode-9ed6fe06-a052-57c2-a234-5d9b94d2e7e0-common": "20.2.0",
+    "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common": "20.2.0",
+    "@codingame/monaco-vscode-a654b07e-8806-5425-b124-18f03ba8e11a-common": "20.2.0",
+    "@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common": "20.2.0",
+    "@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common": "20.2.0",
+    "@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common": "20.2.0",
+    "@codingame/monaco-vscode-ac93482b-2178-52df-a200-ba0d1a4963fb-common": "20.2.0",
+    "@codingame/monaco-vscode-api": "20.2.0",
+    "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common": "20.2.0",
+    "@codingame/monaco-vscode-bb83fe45-f4c7-5673-b9f1-5c409a63f19c-common": "20.2.0",
+    "@codingame/monaco-vscode-bc8c28cd-7a80-54a9-af1a-e6b1e7a7f34a-common": "20.2.0",
+    "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common": "20.2.0",
+    "@codingame/monaco-vscode-d0569cfb-4706-5ad6-b0b0-5115ad8685db-common": "20.2.0",
+    "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common": "20.2.0",
+    "@codingame/monaco-vscode-dc3fa21d-a483-5b99-a7ab-173235644a34-common": "20.2.0",
+    "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common": "20.2.0",
+    "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common": "20.2.0",
+    "@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common": "20.2.0",
+    "@codingame/monaco-vscode-f1bbc6d3-6129-583c-a2ba-c80b832993d2-common": "20.2.0",
+    "@codingame/monaco-vscode-f24e325c-2ce0-5bba-8236-bfc4f53180ab-common": "20.2.0"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/base/common/decorators/cancelPreviousCalls.d.ts

@@ -1,9 +1,82 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+/**
+ * Helper type that represents a function that has an optional {@linkcode CancellationToken}
+ * argument argument at the end of the arguments list.
+ *
+ * @typeparam `TFunction` - Type of the function arguments list of which will be extended
+ * 							with an optional {@linkcode CancellationToken} argument.
+ */
 type TWithOptionalCancellationToken<TFunction extends Function> = TFunction extends (...args: infer TArgs) => infer TReturn ? (...args: [
     ...TArgs,
     cancellatioNToken?: CancellationToken
 ]) => TReturn : never;
+/**
+ * Decorator that provides a mechanism to cancel previous calls of the decorated method
+ * by providing a `cancellation token` as the last argument of the method, which gets
+ * cancelled immediately on subsequent call of the decorated method.
+ *
+ * Therefore to use this decorator, the two conditions must be met:
+ *
+ * - the decorated method must have an *optional* {@linkcode CancellationToken} argument at
+ * 	 the end of the arguments list
+ * - the object that the decorated method belongs to must implement the {@linkcode Disposable};
+ *   this requirement comes from the internal implementation of the decorator that
+ *   creates new resources that need to be eventually disposed by someone
+ *
+ * @typeparam `TObject` - Object type that the decorated method belongs to.
+ * @typeparam `TArgs` - Argument list of the decorated method.
+ * @typeparam `TReturn` - Return value type of the decorated method.
+ *
+ * ### Examples
+ *
+ * ```typescript
+ * // let's say we have a class that implements the `Disposable` interface that we want
+ * // to use the decorator on
+ * class Example extends Disposable {
+ * 		async doSomethingAsync(arg1: number, arg2: string): Promise<void> {
+ * 			// do something async..
+ * 			await new Promise(resolve => setTimeout(resolve, 1000));
+ * 		}
+ * }
+ * ```
+ *
+ * ```typescript
+ * // to do that we need to add the `CancellationToken` argument to the end of args list
+ * class Example extends Disposable {
+ * 		@cancelPreviousCalls
+ * 		async doSomethingAsync(arg1: number, arg2: string, cancellationToken?: CancellationToken): Promise<void> {
+ * 			console.log(`call with args ${arg1} and ${arg2} initiated`);
+ *
+ * 			// the decorator will create the cancellation token automatically
+ * 			assertDefined(
+ * 				cancellationToken,
+ * 				`The method must now have the `CancellationToken` passed to it.`,
+ * 			);
+ *
+ * 			cancellationToken.onCancellationRequested(() => {
+ * 				console.log(`call with args ${arg1} and ${arg2} was cancelled`);
+ * 			});
+ *
+ * 			// do something async..
+ * 			await new Promise(resolve => setTimeout(resolve, 1000));
+ *
+ * 			// check cancellation token state after the async operations
+ * 			console.log(
+ * 				`call with args ${arg1} and ${arg2} completed, canceled?: ${cancellationToken.isCancellationRequested}`,
+ * 			);
+ * 		}
+ * }
+ *
+ * const example = new Example();
+ * // call the decorate method first time
+ * example.doSomethingAsync(1, 'foo');
+ * // wait for 500ms which is less than 1000ms of the async operation in the first call
+ * await new Promise(resolve => setTimeout(resolve, 500));
+ * // calling the decorate method second time cancels the token passed to the first call
+ * example.doSomethingAsync(2, 'bar');
+ * ```
+ */
 export declare function cancelPreviousCalls<TObject extends Disposable, TArgs extends unknown[], TReturn extends unknown>(_proto: TObject, methodName: string, descriptor: TypedPropertyDescriptor<TWithOptionalCancellationToken<(...args: TArgs) => TReturn>>): TypedPropertyDescriptor<(...args: [
     ...TArgs,
     cancellatioNToken?: CancellationToken | undefined

package/vscode/src/vs/base/common/policy.d.ts

@@ -6,9 +6,36 @@ export declare enum PolicyTag {
     Agent = "AGENT"
 }
 export interface IPolicy {
+    /**
+     * The policy name.
+     */
     readonly name: PolicyName;
+    /**
+     * The Code version in which this policy was introduced.
+    */
     readonly minimumVersion: `${number}.${number}`;
+    /**
+     * The policy description (optional).
+     */
     readonly description?: string;
+    /**
+     * The value that an ACCOUNT-based feature will use when its corresponding policy is active.
+     *
+     * Only applicable when policy is tagged with ACCOUNT. When an account-based feature's policy is enabled,
+     * this value determines what value the feature receives.
+     *
+     * For example:
+     * - If `defaultValue: true`,  the feature's setting is locked to `true` WHEN the policy is in effect.
+     * - If `defaultValue: 'foo'`, the feature's setting is locked to 'foo'  WHEN the policy is in effect.
+     *
+     * If omitted, 'false' is the assumed value.
+     *
+     * Note: This is unrelated to the default value of the VS Code setting itself. This specifically controls
+     * the value of an account-based feature's setting WHEN the policy is overriding it.
+     */
     readonly defaultValue?: string | number | boolean;
+    /**
+     * Tags for categorizing policies
+     */
     readonly tags?: PolicyTag[];
 }

package/vscode/src/vs/editor/common/diff/documentDiffProvider.d.ts

@@ -3,20 +3,61 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { MovedText } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/linesDiffComputer";
 import { DetailedLineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+/**
+ * A document diff provider computes the diff between two text models.
+ * @internal
+ */
 export interface IDocumentDiffProvider {
+    /**
+     * Computes the diff between the text models `original` and `modified`.
+     */
     computeDiff(original: ITextModel, modified: ITextModel, options: IDocumentDiffProviderOptions, cancellationToken: CancellationToken): Promise<IDocumentDiff>;
+    /**
+     * Is fired when settings of the diff algorithm change that could alter the result of the diffing computation.
+     * Any user of this provider should recompute the diff when this event is fired.
+     */
     onDidChange: Event<void>;
 }
+/**
+ * Options for the diff computation.
+ * @internal
+ */
 export interface IDocumentDiffProviderOptions {
+    /**
+     * When set to true, the diff should ignore whitespace changes.
+     */
     ignoreTrimWhitespace: boolean;
+    /**
+     * A diff computation should throw if it takes longer than this value.
+     */
     maxComputationTimeMs: number;
+    /**
+     * If set, the diff computation should compute moves in addition to insertions and deletions.
+     */
     computeMoves: boolean;
     extendToSubwords?: boolean;
 }
+/**
+ * Represents a diff between two text models.
+ * @internal
+ */
 export interface IDocumentDiff {
+    /**
+     * If true, both text models are identical (byte-wise).
+     */
     readonly identical: boolean;
+    /**
+     * If true, the diff computation timed out and the diff might not be accurate.
+     */
     readonly quitEarly: boolean;
+    /**
+     * Maps all modified line ranges in the original to the corresponding line ranges in the modified text model.
+     */
     readonly changes: readonly DetailedLineRangeMapping[];
+    /**
+     * Sorted by original line ranges.
+     * The original line ranges and the modified line ranges must be disjoint (but can be touching).
+     */
     readonly moves: readonly MovedText[];
 }
 export declare const nullDocumentDiff: IDocumentDiff;

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatClearActions.d.ts

@@ -1,6 +1,16 @@
 export interface INewEditSessionActionContext {
+    /**
+     * An initial prompt to write to the chat.
+     */
     inputValue?: string;
+    /**
+     * Selects opening in agent mode or not. If not set, the current mode is used.
+     * This is ignored when coming from a chat view title context.
+     */
     agentMode?: boolean;
+    /**
+     * Whether the inputValue is partial and should wait for further user input. If false or not set, the prompt is sent immediately.
+     */
     isPartialQuery?: boolean;
 }
 export declare function registerNewChatActions(): void;

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatToolPicker.d.ts

@@ -1,3 +1,14 @@
 import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IToolData, ToolSet } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+/**
+ * Main entry point for the tools picker. Supports both QuickPick and QuickTree implementations
+ * based on the 'chat.tools.useTreePicker' workspace setting.
+ *
+ * @param accessor - Service accessor for dependency injection
+ * @param placeHolder - Placeholder text shown in the picker
+ * @param description - Optional description text shown in the picker
+ * @param toolsEntries - Optional initial selection state for tools and toolsets
+ * @param onUpdate - Optional callback fired when the selection changes
+ * @returns Promise resolving to the final selection map, or undefined if cancelled
+ */
 export declare function showToolsPicker(accessor: ServicesAccessor, placeHolder: string, description?: string, toolsEntries?: ReadonlyMap<ToolSet | IToolData, boolean>, onUpdate?: (toolsEntries: ReadonlyMap<ToolSet | IToolData, boolean>) => void): Promise<ReadonlyMap<ToolSet | IToolData, boolean> | undefined>;

package/vscode/src/vs/workbench/contrib/chat/browser/actions/codeBlockOperations.d.ts

@@ -54,6 +54,11 @@ export declare class ApplyCodeBlockOperation {
     private tryToRevealCodeBlock;
     private notify;
 }
+/**
+ * Returns:
+ *  - level: the line's the ident level in tabs
+ *  - length: the number of characters of the leading whitespace
+ */
 export declare function computeIndentation(line: string, tabSize: number): {
     level: number;
     length: number;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedFileEntry.d.ts

@@ -71,6 +71,12 @@ export declare abstract class AbstractChatEditingModifiedFileEntry extends Dispo
     protected _notifyAction(action: ChatUserAction): void;
     private readonly _editorIntegrations;
     getEditorIntegration(pane: IEditorPane): IModifiedFileEntryEditorIntegration;
+    /**
+     * Create the editor integration for this entry and the given editor pane. This will only be called
+     * once (and cached) per pane. The integration is meant to be scoped to this entry only and when the
+     * passed pane/editor changes input, then the editor integration must handle that, e.g use default/null
+     * values
+     */
     protected abstract _createEditorIntegration(editor: IEditorPane): IModifiedFileEntryEditorIntegration;
     abstract readonly changesCount: IObservable<number>;
     acceptStreamingEditsStart(responseModel: IChatResponseModel, tx: ITransaction): void;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedNotebookEntry.d.ts

@@ -38,10 +38,19 @@ export declare class ChatEditingModifiedNotebookEntry extends AbstractChatEditin
     private readonly modifiedModel;
     private readonly originalModel;
     originalURI: URI;
+    /**
+     * JSON stringified version of the original notebook.
+     */
     initialContent: string;
+    /**
+     * Whether we're still generating diffs from a response.
+     */
     private _isProcessingResponse;
     get isProcessingResponse(): IObservable<boolean>;
     private _isEditFromUs;
+    /**
+     * Whether all edits are from us, e.g. is possible a user has made edits, then this will be false.
+     */
     private _allEditsAreFromUs;
     private readonly _changesCount;
     changesCount: IObservable<number>;
@@ -49,6 +58,12 @@ export declare class ChatEditingModifiedNotebookEntry extends AbstractChatEditin
     private modifiedToOriginalCell;
     private readonly _cellsDiffInfo;
     get cellsDiffInfo(): IObservable<ICellDiffInfo[]>;
+    /**
+     * List of Cell URIs that are edited,
+     * Will be cleared once all edits have been accepted.
+     * I.e. this will only contain URIS while acceptAgentEdits is being called & before `isLastEdit` is sent.
+     * I.e. this is populated only when edits are being streamed.
+     */
     private readonly editedCells;
     static create(uri: URI, _multiDiffEntryDelegate: {
         collapse: (transaction: ITransaction | undefined) => void;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingSession.d.ts

@@ -31,6 +31,9 @@ export declare class ChatEditingSession extends Disposable implements IChatEditi
     private readonly _accessibilitySignalService;
     private readonly _state;
     private readonly _timeline;
+    /**
+     * Contains the contents of a file when the AI first began doing edits to it.
+     */
     private readonly _initialFileContents;
     private readonly _entriesObs;
     get entries(): IObservable<readonly IModifiedFileEntry[]>;
@@ -53,6 +56,9 @@ export declare class ChatEditingSession extends Disposable implements IChatEditi
     getSnapshot(requestId: string, undoStop: string | undefined, snapshotUri: URI): ISnapshotEntry | undefined;
     getSnapshotModel(requestId: string, undoStop: string | undefined, snapshotUri: URI): Promise<ITextModel | null>;
     getSnapshotUri(requestId: string, uri: URI, stopId: string | undefined): URI | undefined;
+    /**
+     * A snapshot representing the state of the working set before a new request has been sent
+     */
     private _pendingSnapshot;
     restoreSnapshot(requestId: string | undefined, stopId: string | undefined): Promise<void>;
     private _restoreSnapshot;
@@ -73,6 +79,11 @@ export declare class ChatEditingSession extends Disposable implements IChatEditi
     private _acceptEdits;
     private _getTelemetryInfoForModel;
     private _resolve;
+    /**
+     * Retrieves or creates a modified file entry.
+     *
+     * @returns The modified file entry.
+     */
     private _getOrCreateModifiedFileEntry;
     private _createModifiedFileEntry;
     private _collapse;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingSessionStorage.d.ts

@@ -25,11 +25,22 @@ export declare class ChatEditingSessionStorage {
     clearState(): Promise<void>;
 }
 export interface IChatEditingSessionSnapshot {
+    /**
+     * Index of this session in the linear history. It's the sum of the lengths
+     * of all {@link stops} prior this one.
+     */
     readonly startIndex: number;
     readonly requestId: string | undefined;
+    /**
+     * Edit stops in the request. Always initially populatd with stopId: undefind
+     * for th request's initial state.
+     *
+     * Invariant: never empty.
+     */
     readonly stops: IChatEditingSessionStop[];
 }
 export interface IChatEditingSessionStop {
+    /** Edit stop ID, first for a request is always undefined. */
     stopId: string | undefined;
     readonly entries: ResourceMap<ISnapshotEntry>;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTextModelChangeService.d.ts

@@ -60,7 +60,13 @@ export declare class ChatEditingTextModelChangeService extends Disposable {
         maxLineNumber: number;
     }>;
     private _applyEdits;
+    /**
+     * Keeps the current modified document as the final contents.
+     */
     keep(): void;
+    /**
+     * Undoes the current modified document as the final contents.
+     */
     undo(): void;
     resetDocumentValues(newOriginal: string | ITextSnapshot | undefined, newModified: string | undefined): Promise<void>;
     private _mirrorEdits;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingTimeline.d.ts

@@ -8,6 +8,9 @@ import { IEditSessionEntryDiff } from "@codingame/monaco-vscode-api/vscode/vs/wo
 import { IChatRequestDisablement } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { AbstractChatEditingModifiedFileEntry } from "./chatEditingModifiedFileEntry.js";
 import { IChatEditingSessionSnapshot, IChatEditingSessionStop } from "./chatEditingSessionStorage.js";
+/**
+ * Timeline/undo-redo stack for ChatEditingSession.
+ */
 export declare class ChatEditingTimeline {
     private readonly _editorWorkerService;
     private readonly _instantiationService;
@@ -23,24 +26,60 @@ export declare class ChatEditingTimeline {
     readonly canRedo: IObservable<boolean>;
     readonly requestDisablement: IObservable<IChatRequestDisablement[]>;
     constructor(_editorWorkerService: IEditorWorkerService, _instantiationService: IInstantiationService, configurationService: IConfigurationService, _textModelService: ITextModelService);
+    /**
+     * Restore the timeline from a saved state (history array and index).
+     */
     restoreFromState(state: {
         history: readonly IChatEditingSessionSnapshot[];
         index: number;
     }, tx: ITransaction): void;
+    /**
+     * Get the snapshot and history index for restoring, given requestId and stopId.
+     * If requestId is undefined, returns undefined (pending snapshot is managed by session).
+     */
     getSnapshotForRestore(requestId: string | undefined, stopId: string | undefined): {
         stop: IChatEditingSessionStop;
         apply(): void;
     } | undefined;
+    /**
+     * Ensures the state of the file in the given snapshot matches the current
+     * state of the {@param entry}. This is used to handle concurrent file edits.
+     *
+     * Given the case of two different edits, we will place and undo stop right
+     * before we `textEditGroup` in the underlying markdown stream, but at the
+     * time those are added the edits haven't been made yet, so both files will
+     * simply have the unmodified state.
+     *
+     * This method is called after each edit, so after the first file finishes
+     * being edits, it will update its content in the second undo snapshot such
+     * that it can be undone successfully.
+     *
+     * We ensure that the same file is not concurrently edited via the
+     * {@link _streamingEditLocks}, avoiding race conditions.
+     *
+     * @param next If true, this will edit the snapshot _after_ the undo stop
+     */
     ensureEditInUndoStopMatches(requestId: string, undoStop: string | undefined, entry: Pick<AbstractChatEditingModifiedFileEntry, "modifiedURI" | "createSnapshot" | "equalsSnapshot">, next: boolean, tx: ITransaction | undefined): void;
+    /**
+     * Get the undo snapshot (previous in history), or undefined if at start.
+     * If the timeline is at the end of the history, it will return the last stop
+     * pushed into the history.
+     */
     getUndoSnapshot(): {
         stop: IChatEditingSessionStop;
         apply(): void;
     } | undefined;
+    /**
+     * Get the redo snapshot (next in history), or undefined if at end.
+     */
     getRedoSnapshot(): {
         stop: IChatEditingSessionStop;
         apply(): void;
     } | undefined;
     private getUndoRedoSnapshot;
+    /**
+     * Get the state for persistence (history and index).
+     */
     getStateForPersistence(): {
         history: readonly IChatEditingSessionSnapshot[];
         index: number;
@@ -49,6 +88,11 @@ export declare class ChatEditingTimeline {
     private findEditStop;
     private getHistoryEntryByLinearIndex;
     pushSnapshot(requestId: string, undoStop: string | undefined, snapshot: IChatEditingSessionStop): void;
+    /**
+     * Gets diff for text entries between stops.
+     * @param entriesContent Observable that observes either snapshot entry
+     * @param modelUrisObservable Observable that observes only the snapshot URIs.
+     */
     private _entryDiffBetweenTextStops;
     private _createDiffBetweenStopsObservable;
     getEntryDiffBetweenStops(uri: URI, requestId: string | undefined, stopId: string | undefined): IObservable<IEditSessionEntryDiff | undefined>;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/chatEditingNewNotebookContentEdits.d.ts

@@ -2,6 +2,17 @@ import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/l
 import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
 import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
 import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+/**
+ * When asking LLM to generate a new notebook, LLM might end up generating the notebook
+ * using the raw file format.
+ * E.g. assume we ask LLM to generate a new Github Issues notebook, LLM might end up
+ * genrating the notebook using the JSON format of github issues file.
+ * Such a format is not known to copilot extension and those are sent over as regular
+ * text edits for the Notebook URI.
+ *
+ * In such cases we should accumulate all of the edits, generate the content and deserialize the content
+ * into a notebook, then generate notebooke edits to insert these cells.
+ */
 export declare class ChatEditingNewNotebookContentEdits {
     private readonly notebook;
     private readonly _notebookService;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/chatEditingNotebookCellEntry.d.ts

@@ -10,6 +10,11 @@ import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/w
 import { NotebookCellTextModel } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
 import { ModifiedFileEntryState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
 import { IChatResponseModel } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+/**
+ * This is very closely similar to the ChatEditingModifiedDocumentEntry class.
+ * Most of the code has been borrowed from there, as a cell is effectively a document.
+ * Hence most of the same functionality applies.
+ */
 export declare class ChatEditingNotebookCellEntry extends Disposable {
     readonly notebookUri: URI;
     readonly cell: NotebookCellTextModel;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/helpers.d.ts

@@ -6,10 +6,23 @@ export declare function adjustCellDiffForRevertingADeletedCell(originalCellIndex
 export declare function adjustCellDiffForRevertingAnInsertedCell(modifiedCellIndex: number, cellDiffInfo: ICellDiffInfo[], applyEdits: typeof NotebookTextModel.prototype.applyEdits): ICellDiffInfo[];
 export declare function adjustCellDiffForKeepingAnInsertedCell(modifiedCellIndex: number, cellDiffInfo: ICellDiffInfo[], cellToInsert: ICellDto2, applyEdits: typeof NotebookTextModel.prototype.applyEdits, createModifiedCellDiffInfo: (modifiedCellIndex: number, originalCellIndex: number) => ICellDiffInfo): ICellDiffInfo[];
 export declare function adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change: NotebookCellTextModelSplice<ICell>, cellDiffInfo: ICellDiffInfo[], modifiedModelCellCount: number, originalModelCellCount: number, applyEdits: typeof NotebookTextModel.prototype.applyEdits, createModifiedCellDiffInfo: (modifiedCellIndex: number, originalCellIndex: number) => ICellDiffInfo): ICellDiffInfo[];
+/**
+ * Given the movements of cells in modified notebook, adjust the ICellDiffInfo[] array
+ * and generate edits for the old notebook (if required).
+ * TODO@DonJayamanne Handle bulk moves (movements of more than 1 cell).
+ */
 export declare function adjustCellDiffAndOriginalModelBasedOnCellMovements(event: NotebookCellsModelMoveEvent<ICell>, cellDiffInfo: ICellDiffInfo[]): [
     ICellDiffInfo[],
     ICellEditOperation[]
 ] | undefined;
 export declare function getCorrespondingOriginalCellIndex(modifiedCellIndex: number, cellDiffInfo: ICellDiffInfo[]): number | undefined;
+/**
+ *
+ * This isn't great, but necessary.
+ * ipynb extension updates metadata when new cells are inserted (to ensure the metadata is correct)
+ * Details of why thats required is in ipynb extension, but its necessary.
+ * However as a result of this, those edits appear here and are assumed to be user edits.
+ * As a result `_allEditsAreFromUs` is set to false.
+ */
 export declare function isTransientIPyNbExtensionEvent(notebookKind: string, e: NotebookTextModelChangedEvent): boolean;
 export declare function calculateNotebookRewriteRatio(cellsDiff: ICellDiffInfo[], originalModel: NotebookTextModel, modifiedModel: NotebookTextModel): number;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/notebookCellChanges.d.ts

@@ -2,6 +2,14 @@ import { ISettableObservable, ObservablePromise } from "@codingame/monaco-vscode
 import { IDocumentDiff } from "../../../../../../editor/common/diff/documentDiffProvider.js";
 import { DetailedLineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+/**
+ * This structure is used to represent the state of a Notebook document compared to the original.
+ * Its similar to the IDocumentDiff object, that tells us what cells are unmodified, modified, inserted or deleted.
+ *
+ * All entries will contain a IDocumentDiff
+ * Even when there are no changes, diff will contain the number of lines in the document.
+ * This way we can always calculate the total number of lines in the document.
+ */
 export type ICellDiffInfo = {
     originalCellIndex: number;
     modifiedCellIndex: number;
@@ -20,8 +28,19 @@ export type ICellDiffInfo = {
     type: "insert";
 } & IDocumentDiffWithModelsAndActions;
 interface IDocumentDiffWithModelsAndActions {
+    /**
+     * The changes between the original and modified document.
+     */
     diff: ISettableObservable<IDocumentDiff>;
+    /**
+     * The original model.
+     * Cell text models load asynchronously, so this is an observable promise.
+     */
     originalModel: ObservablePromise<ITextModel>;
+    /**
+     * The modified model.
+     * Cell text models load asynchronously, so this is an observable promise.
+     */
     modifiedModel: ObservablePromise<ITextModel>;
     keep(changes: DetailedLineRangeMapping): Promise<boolean>;
     undo(changes: DetailedLineRangeMapping): Promise<boolean>;

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

@@ -1,5 +1,9 @@
 import { IHoverAction } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover";
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+/**
+ * This borrows some of HoverWidget so that a chat editor hover can be rendered in the same way as a workbench hover.
+ * Maybe it can be reusable in a generic way.
+ */
 export declare class ChatEditorHoverWrapper {
     private readonly keybindingService;
     readonly domNode: HTMLElement;

package/vscode/src/vs/workbench/contrib/chat/browser/contrib/media/editorHoverWrapper.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.
+ *--------------------------------------------------------------------------------------------*/
+
 .chat-editor-hover-wrapper-content {
 	padding: 2px 8px;
 }