Ulugbek Abdullaev

This commit **enhances the `xtab` extension's logging capabilities** by ensuring that **applied filter names are explicitly included in trace logs** whenever filtering operations are performed. The `filterEdit` function in `extensions/copilot/src/extension/xtab/node/xtabProvider.ts` was refactored to return these filter names, thereby **improving observability and debugging** for filter-related issues. This **feature improvement** also includes a new test case in `xtabCustomDiffPatchResponseHandler.spec.ts` to validate the handling of no-op diff patches, contributing to the overall stability of the `xtab` subsystem.

This commit introduces a **new capability** to customize cursor placement following inline edit predictions, specifically for the **Copilot `xtab` provider**. A new configuration setting, `InlineEditsNextCursorPredictionCursorPlacement`, allows users to define whether the cursor should appear before or after the predicted line. The core logic is implemented in `xtabProvider.ts` within the `provideNextEdit` method, supported by a new `getNextCursorColumn` helper and comprehensive tests. This enhancement provides greater control over the editing experience, improving workflow efficiency for **inline code generation**.

This commit implements a **maintenance chore** by **temporarily skipping** a specific integration test suite within the **Copilot extension's MCP (Managed Compute Platform) module**. It targets the `nuget.integration.spec.ts` suite, which is responsible for testing **NuGet server information retrieval using the `dotnet CLI`**. This action addresses **test flakiness** to prevent unreliable CI/CD failures, ensuring build stability. While temporarily reducing test coverage for this specific functionality, it allows development to proceed without interruption from unstable tests until a more robust solution is implemented.

This commit **refines the permissive rebasing logic** within the **Copilot inline edits** feature, specifically in `editRebase.ts`. It ensures that user-typed text is only absorbed during rebasing if it constitutes an **editor auto-close pair**, preventing unintended synchronization for other characters. This **refinement** introduces a new helper function, `isAutoClosePair`, to perform this check. Consequently, the updated tests for `absorbSubsequenceTyping` now expect more rebase failures, reflecting the stricter and more accurate behavior of the system.

This commit **fixes a UI rendering bug** in the **Copilot request log tree view** where `XtabProvider` entries would incorrectly unnest when sibling items were hidden. It achieves this by **refactoring the rendering logic** for `ChatPromptItem` and `CapturingToken`. Specifically, the deprecated `flattenSingleChild` and `promoteMainEntry` arguments are removed from `CapturingToken`, making it a pure correlation token without rendering hints. `ChatPromptItem` now directly owns log context documents via `setMainEntry()`, and `MarkdownContentRequest` items are wired to the parent's icon and command rather than being added as tree children. This ensures the tree view solely manages all rendering conventions, preventing unintended item promotion and improving the stability of the UI.

chore: fix: default formatter for workspace (#4727)

This commit delivers a **bug fix** for the **Copilot `xtab` module**, resolving an issue where the **edit window** for **cached items** was incorrectly determined in patch-based responses. It modifies the `xtabProvider` to calculate and utilize a `pseudoEditWindow` within `_doRequest` for custom diff patch requests, ensuring the correct contextual range is considered. Concurrently, the `xtabCustomDiffPatchResponseHandler` is updated to correctly construct `StreamedEdit` objects by removing the `originalWindow` property and setting `isFromCursorJump` to `false`. This ensures that Copilot's patch-based suggestions are generated with accurate contextual information, enhancing the reliability and precision of its editing capabilities.

This commit introduces **live logging capabilities** for **inline edit requests**, allowing log entries to update dynamically and resolve their content on demand, significantly enhancing the debugging experience. It also **fixes a bug** where the "In progress" status for inline edits would not clear by implementing an **explicit completion flag** (`_isCompleted`) in `inlineEditLogContext.ts` and ensuring it's set in `finally` blocks. The **Request Logging** infrastructure and **Request Log Tree** UI are updated to support these dynamic entries, including throttling UI refreshes and proper resource disposal. These **feature enhancements** and **bug fixes** provide more accurate status reporting and improved observability for inline edit operations.

This commit provides a **bug fix** for the **Copilot extension's inline edits feature**, addressing an issue where the UI would incorrectly render all inline suggestions using a specific "NES UI" style. The problem stemmed from the `createCompletionItem` function being called with an unnecessary URI parameter when the `targetDocument` was the same as the `activeDocument`, leading to misinterpretation of the `isInlineEdit` flag. By **removing this URI parameter** from the `createCompletionItem` function and its calls within `inlineCompletionProvider.ts`, this change ensures that inline edit suggestions are rendered with the appropriate UI, preventing unintended visual behavior and improving the accuracy of the inline editing experience.

This commit **enhances** the **Copilot `nes` (cursor jump) feature** by increasing the maximum token budget for inline edits. Specifically, it **raises the current file's token limit from 2000 to 3000** for the next cursor prediction, as configured within `extensions/copilot/src/platform/configuration/common/configurationService.ts`. This **feature improvement** allows the cursor jump prediction to consider a larger contextual window, leading to **more accurate and intelligent cursor placement** for users interacting with inline code suggestions.

This commit introduces a **bug fix** within the **Copilot extension's inline edits** feature, specifically addressing an issue with **telemetry collection**. It corrects the initialization of `StatelessNextEditResult` in `extensions/copilot/src/extension/inlineEdits/node/nextEditProvider.ts` to ensure that **stateless telemetry** is accurately recorded for the **very first edit suggestion** provided by the **Next Edit Service (NES)**. This change is crucial for gathering reliable data on the initial user experience with NES-driven inline edits, impacting the overall **telemetry system's accuracy**.

This commit introduces a **new capability** to **Copilot's inline edits feature** by adding a configurable setting, `InlineEditsAllowImportChanges`, to control **import filtering**. The core `filterEdit` logic in `importFiltering.ts` and `xtabProvider.ts` is updated to retrieve and apply this new configuration, allowing users to **tweak how import statements are handled** during inline code suggestions. This enhancement provides greater flexibility and control over the generated code, with new tests ensuring the correct behavior of the `filterEdit` function under various import change scenarios.

This commit introduces **significant new capabilities** to the **Copilot Next Edit Suggestion (NES) system**, enabling **cross-file cursor jumps** and **cross-file diff-patch model support**, particularly when `onlyWithEdit` is active. It refactors the `nextEditProvider` to track document state across files and updates the `inlineCompletionProvider` and `xtab` modules to correctly resolve and process edits targeting different files using a new `targetDocument` property. This **new feature** allows Copilot to suggest changes or cursor movements in files other than the currently active one, enhancing multi-file development workflows. Additionally, it includes a **bug fix** to prevent cross-file NES from appearing as confusing inline suggestions and addresses an issue with an undefined `workspaceRoot`.

This commit **introduces support for using vanilla models from the Copilot API (CAPI)** for the **next cursor prediction** feature, often referred to as "cursor jump" or "inline edits". It **refactors** the `XtabNextCursorPredictor` within the **Copilot extension** to utilize an `IEndpointProvider` for resolving chat endpoints and dynamically adjusting token limits based on the API type. As part of this infrastructure, a `NullEndpointProvider` is now registered during service setup in `chatLibMain.ts`. Additionally, a new configuration key, `InlineEditsNextCursorPredictionUseEndpointProvider`, is added to allow enabling or disabling this new endpoint provider mechanism. This enhancement aims to provide more flexible and potentially improved cursor jump suggestions by leveraging a broader range of models.

This commit introduces a **new capability** to control the **Copilot extension's next cursor line prediction** behavior. It adds a `supportsNextCursorLinePrediction` property to the `ModelConfiguration` interface in `xtabPromptOptions.ts`, allowing the prediction system to be explicitly disabled. The **XTab prediction system** in `xtabNextCursorPredictor.ts` and `xtabProvider.ts` is updated to respect this configuration, ensuring that streaming edit methods can prevent unwanted cursor jump calls. This enhancement provides more granular control over the **inline edit experience**, allowing users to disable automatic cursor movements when not desired.

This commit introduces **multi-file cursor jump support** for **inline edits** within the **Copilot extension**, significantly enhancing the editing workflow. It **refactors the `xtabNextCursorPredictor`** to parse and handle next cursor predictions that span across different files, and updates the `xtabProvider` to process these cross-file predictions. The `inlineCompletionProvider` and `nextEditProvider` are modified to pass necessary document identifiers like `targetDocumentId` and `uri`, while telemetry interfaces and configuration are extended to accommodate this **new capability**, including an increase in maximum response tokens. This allows users to seamlessly navigate to predicted cursor positions in other relevant files after an inline edit.

This commit **enhances the logging and diagnostic capabilities** within the **Copilot inline edits feature** by introducing structured details for asynchronous requests and rebase failures. It refactors the `tryRebaseCacheEntry` method in `nextEditCache.ts` to return a comprehensive `RebaseResult` object, replacing simple boolean outcomes with detailed failure information. A new `rebaseResult.ts` file defines the necessary types for capturing rebase failure reasons, and the `nextEditProvider` now integrates this, adding a private method to log these failures. This **feature enhancement** significantly improves **observability and debugging** for rebase-related issues, providing richer context for problem identification.

This commit **fixes** a stability issue within the **Copilot extension's configuration service** by adjusting the default value of a critical setting. Specifically, it changes the default for `InlineEditsAbsorbSubsequenceTyping` from `true` to `false` in `configurationService.ts`. This **configuration adjustment** prevents "rebase failure" scenarios that previously occurred when Copilot attempted to absorb user typing, thereby improving the reliability and user experience of **inline edits**.

This commit performs a **debt cleanup** by **refactoring** the **Copilot extension's inline edits platform**. It **removes the `Always` option** from the `EmitFastCursorLineChange` enum in `responseProcessor.ts`, simplifying the available modes for handling fast cursor line changes. Consequently, the `mapEmitFastCursorLineChange` function was updated to reflect this change, ensuring consistency with the reduced enum options. Related test cases in `responseProcessor.spec.ts` were also adjusted to use `AdditiveOnly` as the new default for `emitFastCursorLineChange`, streamlining the cursor line change emission logic.

This commit provides a **bug fix** for the **Copilot extension's `xtab` provider**, preventing errors when AI chat models return responses with no suggested choices. Specifically, the `doGetNextEdit` function in `extensions/copilot/src/extension/xtab/node/xtabProvider.ts` now explicitly handles cases where diff-patch models yield an empty `choices` array, returning a `RESPONSE_CONTAINED_NO_CHOICES` reason instead of crashing. This improves the **stability and user experience** of the Copilot feature by ensuring graceful degradation when no suggestions are available. The change is supported by new **unit tests** and a **refactoring** to introduce a shared constant for this specific response reason across the `chatMLFetcher` and common types.