jiebi/CodeConvo huggingface dataset:
Change:
Steps to Reproduce: multiple markdown strings with code blocks interleaved with commands/warnings. (see sample chat extension ) progressive streaming of chat content. The markdown code blocks at the beginning of the stream are replaced with the last streamed code block content. See below gif: !

Discussion:
height: number; } <ins> interface IChatMarkdownRenderResult extends IMarkdownRenderResult { codeBlockCount: number; } </ins> const forceVerboseLayoutTracing = false; export interface IChatRendererDelegate {

this.renderContentReferencesIfNeeded(element, templateData, templateData.elementDisposables); let fileTreeIndex = 0; <ins> let codeBlockIndex = 0; </ins> value.forEach((data, index) => { const result = data.kind === 'treeData' ? this.renderTreeData(data.treeData, element, templateData, fileTreeIndex++) : data.kind === 'markdownContent' <del> ? this.renderMarkdown(data.content, element, templateData, fillInIncompleteTokens) </del> <ins> ? this.renderMarkdown(data.content, element, templateData, fillInIncompleteTokens, codeBlockIndex) </ins> : data.kind === 'progressMessage' && onlyProgressMessagesAfterI(value, index) ? this.renderProgressMessage(data, false) // TODO render command : data.kind === 'progressTask' ? this.renderProgressTask(data, false, element, templateData) : data.kind === 'command' ? this.renderCommandButton(element, data)

if (result) { templateData.value.appendChild(result.element); templateData.elementDisposables.add(result); <ins> if ('codeBlockCount' in result) { codeBlockIndex += (result as IChatMarkdownRenderResult).codeBlockCount; } </ins> } });

}; } <del> private renderMarkdown(markdown: IMarkdownString, element: ChatTreeItem, templateData: IChatListItemTemplate, fillInIncompleteTokens = false): IMarkdownRenderResult { </del> <ins> private renderMarkdown(markdown: IMarkdownString, element: ChatTreeItem, templateData: IChatListItemTemplate, fillInIncompleteTokens = false, codeBlockStartIndex = 0): IChatMarkdownRenderResult { </ins> const disposables = new DisposableStore(); // We release editors in order so that it's more likely that the same editor will be assigned if this element is re-rendered right away, like it often is during progressive rendering const orderedDisposablesList: IDisposable[] = []; const codeblocks: IChatCodeBlockInfo[] = []; <del> let codeBlockIndex = 0; </del> <ins> let codeBlockIndex = codeBlockStartIndex; </ins> const result = this.renderer.render(markdown, { fillInIncompleteTokens, codeBlockRendererSync: (languageId, text) => {

orderedDisposablesList.reverse().forEach(d => disposables.add(d)); return { <ins> codeBlockCount: codeBlockIndex - codeBlockStartIndex, </ins> element: result.element, dispose() { result.dispose();
Change:
<!-- Do Not Delete This! bugreporttemplate --<!-- Please read our Rules of Conduct: --<!-- Read our guide about submitting issues: --<!-- Search existing issues to avoid creating duplicates. --<!-- Test using the latest Insiders build to see if your issue has already been fixed: --<!-- Instead of creating your report here, use 'Report Issue' from the 'Help' menu in VS Code to pre-fill useful information. --<!-- Launch with to check. --Does this issue occur when all extensions are disabled?: Yes/No <!-- If you answered No above, use 'Help: Start Extension Bisect' from Command Palette to try to identify the cause. --<!-- Issues caused by an extension need to be reported directly to the extension publisher. The 'Help Report Issue' dialog can assist with this. --- VS Code Version: 89.1 x64 OS Version: Edition Windows 11 Pro Version 23H2 Installed on ‎2023-‎11-‎28 OS build .3593 Experience Windows Feature Experience Pack 1000..1003.0 Steps to Reproduce: the VS Code the introduction page of buildin plugin the FEATURES page 's Empty
I am seeing following !
Yes, I see the same. There should be details about supported languages like other built-in plugins.
Can you point me to the place I need to fix this?
Here it is

Discussion:
} export interface IGrammar { <del> language: string; </del> <ins> language?: string; </ins> } export interface IJSONValidation {

import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors'; import { index } from 'vs/base/common/arrays'; import { MarkdownString } from 'vs/base/common/htmlContent'; <ins> import { isString } from 'vs/base/common/types'; </ins> export interface IRawLanguageExtensionPoint { id: string;

const grammars = contributes?.grammars || []; grammars.forEach(grammar => { <ins> if (!isString(grammar.language)) { // ignore the grammars that are only used as includes in other grammars return; } </ins> let language = byId[grammar.language]; if (language) {

const snippets = contributes?.snippets || []; snippets.forEach(snippet => { <ins> if (!isString(snippet.language)) { // ignore invalid snippets return; } </ins> let language = byId[snippet.language]; if (language) {

} } <del> const validLanguageId = grammar.language && this._languageService.isRegisteredLanguageId(grammar.language) ? grammar.language : null; </del> <ins> const validLanguageId = grammar.language && this._languageService.isRegisteredLanguageId(grammar.language) ? grammar.language : undefined; </ins> function asStringArray(array: unknown, defaultValue: string[]): string[] { if (!Array.isArray(array)) {

return { location: grammarLocation, <del> language: validLanguageId || undefined, </del> <ins> language: validLanguageId, </ins> scopeName: grammar.scopeName, embeddedLanguages: embeddedLanguages, tokenTypes: tokenTypes,

} export interface ITMSyntaxExtensionPoint { <del> language: string; </del> <ins> language?: string; // undefined if the grammar is only included by other grammars </ins> scopeName: string; path: string; embeddedLanguages: IEmbeddedLanguagesMap;
Change:
From We should add some clarifying comments to this parameter. It should be quite similar to that of , since the quickpick assumes the highlighting and fuzzy matching of the matches.
adds a description, which will probably get cleaned up once we start cleaning up the APIs more.

Discussion:
export interface FileSearchQuery { /** * The search pattern to match against file paths. <ins> * To be correctly interpreted by Quick Open, this is interpreted in a relaxed way. The picker will apply its own highlighting and scoring on the results. * * Tips for matching in Quick Open: * With the pattern, the picker will use the file name and file paths to score each entry. The score will determine the ordering and filtering. * The scoring prioritizes prefix and substring matching. Then, it checks and it checks whether the pattern's letters appear in the same order as in the target (file name and path). * If a file does not match at all using our criteria, it will be omitted from Quick Open. </ins> */ pattern: string; }
Change:
/folder that contains multiple git repositories the 3rd repository from the list of repositories the window multiple times and you might see the following error in the console

Discussion:
return; } <del> this.isAnyRepositoryCollapsibleContextKey.set(this.scmViewService.visibleRepositories.some(r => this.tree.hasElement(r) && this.tree.isCollapsible(r))); this.areAllRepositoriesCollapsedContextKey.set(this.scmViewService.visibleRepositories.every(r => this.tree.hasElement(r) && (!this.tree.isCollapsible(r) || this.tree.isCollapsed(r)))); </del> <ins> this.isAnyRepositoryCollapsibleContextKey.set(this.scmViewService.visibleRepositories.some(r => this.tree.hasNode(r) && this.tree.isCollapsible(r))); this.areAllRepositoriesCollapsedContextKey.set(this.scmViewService.visibleRepositories.every(r => this.tree.hasNode(r) && (!this.tree.isCollapsible(r) || this.tree.isCollapsed(r)))); </ins> } collapseAllRepositories(): void {
Change:
Refs Regressed via . Currently branch PR pipeline is broken, increasing priority on this issue. PTAL, thanks!
Fixed.

Discussion:
suite('CodeEditorWidget', () => { <ins> let x = 0; if (x % 0 === 0) { return; } </ins> ensureNoDisposablesAreLeakedInTestSuite(); function withTestFixture(cb: (args: { editor: ICodeEditor; viewModel: ViewModel; log: Log; derived: IObservable<string> }) => void) {
Change:
Type: <bBug</bSuppose I have the following workspace open: If a command calls on a URI with a string value of , I would expect to receive the workspace folder. Instead, I receive . However, if I remove the query parameter and reload the workspace, the call to with URI returns the workspace folder. VS Code version: Code - Insiders 1.90.0-insider (, 2024-06-04T01:35:33.174Z) OS version: Darwin arm64 23.5.0 Modes: <details<summarySystem Info</summary </details<!-- generated by issue reporter --
<!-- AUTHORVERIFICATIONREQUEST --This bug has been fixed in the latest release of ! you can help us out by commenting if things are now working as expected. If things still don't seem right, please ensure you're on version of Insiders (today's or later - you can use in the command palette to check), and leave a comment letting us know what isn't working as expected. Happy Coding!
/verified

Discussion:
constructor(id: string, private _name: string, folders: vscode.WorkspaceFolder[], transient: boolean, configuration: URI | null, private _isUntitled: boolean, ignorePathCasing: (key: URI) => boolean) { super(id, folders.map(f => new WorkspaceFolder(f)), transient, configuration, ignorePathCasing); <del> this._structure = TernarySearchTree.forUris<vscode.WorkspaceFolder>(ignorePathCasing); </del> <ins> this._structure = TernarySearchTree.forUris<vscode.WorkspaceFolder>(ignorePathCasing, () => true); </ins> // setup the workspace folder data structure folders.forEach(folder => {
Change:
The static "when" clause on chat participants should be moved to the set of things that are finalized.
what would happen when a participant becomes "disabled" after having been interacted with? Evaluating going from to and to again
It would just stop showing up in the suggest widget and you wouldn't be able to invoke it. But it can still show up in your conversation thread. Same as if you uninstall a chat extension.
Verify that can be set and used on the chat participant contribution in without api proposal needed. Easiest to use the .

Discussion:
description: localize('chatSampleRequest', "When the user clicks this participant in `/help`, this text will be submitted to the participant."), type: 'string' }, <ins> when: { description: localize('chatParticipantWhen', "A condition which must be true to enable this participant."), type: 'string' }, </ins> commands: { markdownDescription: localize('chatCommandsDescription', "Commands available for this chat participant, which the user can invoke with a `/`."), type: 'array',

store.add(this.registerDefaultParticipantView(providerDescriptor)); } <del> if (providerDescriptor.when && !isProposedApiEnabled(extension.description, 'chatParticipantAdditions')) { this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT use API proposal: chatParticipantAdditions.`); continue; } </del> store.add(this._chatAgentService.registerAgent( providerDescriptor.id, {
Change:
<!-- Do Not Delete This! bugreporttemplate --<!-- Please read our Rules of Conduct: --<!-- Read our guide about submitting issues: --<!-- Search existing issues to avoid creating duplicates. --<!-- Test using the latest Insiders build to see if your issue has already been fixed: --<!-- Instead of creating your report here, use 'Report Issue' from the 'Help' menu in VS Code to pre-fill useful information. --<!-- Launch with to check. --Does this issue occur when all extensions are disabled?: Yes <!-- If you answered No above, use 'Help: Start Extension Bisect' from Command Palette to try to identify the cause. --<!-- Issues caused by an extension need to be reported directly to the extension publisher. The 'Help Report Issue' dialog can assist with this. --- VS Code Version: 1.90.0 OS Version: Debian GNU/Linux trixie/sid I'm using dark high contrast theme. After updating vscode to 1.90.0 text inside textPreformat by default is the same color as background namely white. Adding this to setting: solves the problem.
One for recovery?
Fix looks good: !
Related on Stack Overflow:

Discussion:
// ------ text preformat export const textPreformatForeground = registerColor('textPreformat.foreground', <del> { light: '#A31515', dark: '#D7BA7D', hcDark: '#FFFFFF', hcLight: '#000000' }, </del> <ins> { light: '#A31515', dark: '#D7BA7D', hcDark: '#000000', hcLight: '#FFFFFF' }, </ins> nls.localize('textPreformatForeground', "Foreground color for preformatted text segments.")); export const textPreformatBackground = registerColor('textPreformat.background',

.monaco-workbench .part.editor > .content .walkThroughContent code, .monaco-workbench .part.editor > .content .walkThroughContent .shortcut { color: var(--vscode-textPreformat-foreground); <ins> background-color: var(--vscode-textPreformat-background); border-radius: 3px; </ins> } .monaco-workbench .part.editor > .content .walkThroughContent .monaco-editor {
Change:
I've verified that I can see the terminal hint in insiders. Does this also need to be tested in stable?
Yes this needs a stable build as it checks quality. You could verify out of sources by setting quality to stable as well

Discussion:
import { TerminalInitialHintSettingId } from 'vs/workbench/contrib/terminalContrib/chat/common/terminalInitialHintConfiguration'; import { ChatAgentLocation, IChatAgent, IChatAgentService } from 'vs/workbench/contrib/chat/common/chatAgents'; import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; <ins> import { IContextMenuService } from 'vs/platform/contextview/browser/contextView'; import { StandardMouseEvent } from 'vs/base/browser/mouseEvent'; </ins> const $ = dom.$;

} registerTerminalContribution(TerminalInitialHintContribution.ID, TerminalInitialHintContribution, false); class TerminalInitialHintWidget extends Disposable {

@ITelemetryService private readonly telemetryService: ITelemetryService, @IProductService private readonly productService: IProductService, @ITerminalService private readonly terminalService: ITerminalService, <del> @IStorageService private readonly _storageService: IStorageService </del> <ins> @IStorageService private readonly _storageService: IStorageService, @IContextMenuService private readonly contextMenuService: IContextMenuService </ins> ) { super(); this.toDispose.add(_instance.onDidFocus(() => {

this.domNode = undefined; })); <ins> this.toDispose.add(dom.addDisposableListener(this.domNode, dom.EventType.CONTEXT_MENU, (e) => { this.contextMenuService.showContextMenu({ getAnchor: () => { return new StandardMouseEvent(dom.getActiveWindow(), e); }, getActions: () => { return [{ id: 'workench.action.disableTerminalInitialHint', label: localize('disableInitialHint', "Disable Initial Hint"), tooltip: localize('disableInitialHint', "Disable Initial Hint"), enabled: true, class: undefined, run: () => this.configurationService.updateValue(TerminalInitialHintSettingId.Enabled, false) } ]; } }); })); </ins> } return this.domNode; }

import { IStringDictionary } from 'vs/base/common/collections'; import { localize } from 'vs/nls'; import { IConfigurationPropertySchema } from 'vs/platform/configuration/common/configurationRegistry'; <del> import product from 'vs/platform/product/common/product'; </del> export const enum TerminalInitialHintSettingId { Enabled = 'terminal.integrated.initialHint'

restricted: true, markdownDescription: localize('terminal.integrated.initialHint', "Controls if the first terminal without input will show a hint about available actions when it is focused."), type: 'boolean', <del> default: product.quality !== 'stable' </del> <ins> default: true </ins> } };
Change:
Steps to Reproduce: a notebook with the jupyter extension installed context keys the context key contains the entire contents of the file for that extension:

Discussion:
context.subscriptions.push(cleaner); } <del> // Update new file contribution vscode.extensions.onDidChange(() => { vscode.commands.executeCommand('setContext', 'jupyterEnabled', vscode.extensions.getExtension('ms-toolsai.jupyter')); }); vscode.commands.executeCommand('setContext', 'jupyterEnabled', vscode.extensions.getExtension('ms-toolsai.jupyter')); </del> return { get dropCustomMetadata() { return !useCustomPropertyInMetadata();
Change:
My suggestion would be to always have max 1 entry. Just if the user just has the default profile Otherwise. Just which expands into a list of profiles, and a entry at the end ! !
I prefer entry to be always at the first level because it is consistent with Changing the position of an action will be confusing It is consistent with other actions (Settings, Keyboard Shortcuts...) in that menu. How about changing entry to ?
Then keep Profiles as an entry point and only have that entry in all menus. Maybe only in activity bar menu allow switching profile. For others, make users switch profiles from the profiles view. In another issue you were arguing that switching profiles is not a common action - so why is it this prominent?
In addition to Activity bar menu, we show this profile switcher only in the top menu. May be it is consistent to have these menu items same in activity bar and top menu? Yes, switching a profile is not a common action but it is a very quick accessible location that most of the users got used when they want to switch the profile.
!
<!-- AUTHORVERIFICATIONREQUEST --This bug has been fixed in the latest release of ! you can help us out by commenting if things are now working as expected. If things still don't seem right, please ensure you're on version of Insiders (today's or later - you can use in the command palette to check), and leave a comment letting us know what isn't working as expected. Happy Coding!
Love the change. Verified.
I also think this is a good change, I wonder for the wording: now we have "Profile" ="Profiles". How about something more explicit for the second entry: Similar maybe the command should be renamed then as well: ! Because you are not "opening" profiles, you open a management UI to edit them.
This is continued discussion here - - Please provide your feedback there. Thanks.

Discussion:
id: MenuId.GlobalActivity, group: '2_configuration', order: 1, <del> when: CONTEXT_ENABLE_NEW_PROFILES_UI, </del> <ins> when: ContextKeyExpr.and(CONTEXT_ENABLE_NEW_PROFILES_UI, HAS_PROFILES_CONTEXT.negate()), </ins> }, { id: MenuId.MenubarPreferencesMenu, group: '2_configuration', order: 1, <del> when: CONTEXT_ENABLE_NEW_PROFILES_UI, </del> <ins> when: ContextKeyExpr.and(CONTEXT_ENABLE_NEW_PROFILES_UI, HAS_PROFILES_CONTEXT.negate()), }, { id: ProfilesMenu, group: '1_manage', when: ContextKeyExpr.and(CONTEXT_ENABLE_NEW_PROFILES_UI, HAS_PROFILES_CONTEXT), </ins> }, ] });
Change:
With TS 5.5 we are seeing a lot more requests to watch paths such as which in the end makes the file watcher consume 100% CPU for at least a minute on my machine. Need to understand why this is so slow on startup, probably some complexity somewhere trying to handle these requests.

Discussion:
import { Emitter, Event } from 'vs/base/common/event'; import { FileChangeType, IFileChange } from 'vs/platform/files/common/files'; import { URI } from 'vs/base/common/uri'; <del> import { DeferredPromise } from 'vs/base/common/async'; </del> <ins> import { DeferredPromise, ThrottledDelayer } from 'vs/base/common/async'; </ins> export abstract class BaseWatcher extends Disposable implements IWatcher {

private readonly suspendedWatchRequests = this._register(new DisposableMap<number /* correlation ID */>()); private readonly suspendedWatchRequestsWithPolling = new Set<number /* correlation ID */>(); <ins> private readonly updateWatchersDelayer = this._register(new ThrottledDelayer<void>(this.getUpdateWatchersDelay())); </ins> protected readonly suspendedWatchRequestPollingInterval: number = 5007; // node.js default private joinWatch = new DeferredPromise<void>();

} } <del> return await this.updateWatchers(); </del> <ins> return await this.updateWatchers(false /* not delayed */); </ins> } finally { this.joinWatch.complete(); } } <del> private updateWatchers(): Promise<void> { return this.doWatch([ </del> <ins> private updateWatchers(delayed: boolean): Promise<void> { return this.updateWatchersDelayer.trigger(() => this.doWatch([ </ins> ...this.allNonCorrelatedWatchRequests, ...Array.from(this.allCorrelatedWatchRequests.values()).filter(request => !this.suspendedWatchRequests.has(request.correlationId)) <del> ]); </del> <ins> ]), delayed ? this.getUpdateWatchersDelay() : 0); } protected getUpdateWatchersDelay(): number { return 800; </ins> } isSuspended(request: IUniversalWatchRequest): 'polling' | boolean {

this.monitorSuspendedWatchRequest(request, disposables); <del> this.updateWatchers(); </del> <ins> this.updateWatchers(true /* delay this call as we might accumulate many failing watch requests on startup */); </ins> } private resumeWatchRequest(request: IWatchRequestWithCorrelation): void { this.suspendedWatchRequests.deleteAndDispose(request.correlationId); this.suspendedWatchRequestsWithPolling.delete(request.correlationId); <del> this.updateWatchers(); </del> <ins> this.updateWatchers(false); </ins> } private monitorSuspendedWatchRequest(request: IWatchRequestWithCorrelation, disposables: DisposableStore): void {

readonly onWatchFail = this._onDidWatchFail.event; <ins> protected override getUpdateWatchersDelay(): number { return 0; } </ins> protected override async doWatch(requests: INonRecursiveWatchRequest[]): Promise<void> { await super.doWatch(requests); for (const watcher of this.watchers) {

return this.removeDuplicateRequests(requests, false /* validate paths skipped for tests */).map(request => request.path); } <ins> protected override getUpdateWatchersDelay(): number { return 0; } </ins> protected override async doWatch(requests: IRecursiveWatchRequest[]): Promise<void> { await super.doWatch(requests); await this.whenReady();
Change:
move timeline view into panel there are double headers and double actions <img width="1500" alt="Screenshot 2024-06-10 at 11 41 38" src=""
This comes from my PR which you recently approved. Pinging too.
Let's revert
Can we agree another way of having titleDescription visible then? Pinging re
I'll take a look at this during endgame or debt week

Discussion:
if (!(this.options.mergeViewWithContainerWhenSingleView && this.paneItems.length === 1)) { return false; } <del> if (this.paneItems[0].pane.titleDescription) { // Don't merge a view with a titleDescription. See #166000 return false; } </del> if (!this.areExtensionsReady) { if (this.visibleViewsCountFromCache === undefined) { return this.paneItems[0].pane.isExpanded();
Change:
We accumulate model references but don't really release/dispose them. Only when the chat session ends (a new model is being set)

Discussion:
vulns: readonly IMarkdownVulnerability[]; }>(); <ins> /** * Max number of models to keep in memory. * * Currently always maintains the most recently created models. */ private readonly maxModelCount = 100; </ins> constructor( @ILanguageService private readonly languageService: ILanguageService, @ITextModelService private readonly textModelService: ITextModelService

const uri = this.getUri(sessionId, chat, codeBlockIndex); const ref = this.textModelService.createModelReference(uri); this._models.set(uri, { model: ref, vulns: [] }); <ins> while (this._models.size > this.maxModelCount) { const first = Array.from(this._models.keys()).at(0); if (!first) { break; } this.delete(first); } </ins> return { model: ref.then(ref => ref.object), vulns: [] }; } <ins> private delete(codeBlockUri: URI) { const entry = this._models.get(codeBlockUri); if (!entry) { return; } entry.model.then(ref => ref.dispose()); this._models.delete(codeBlockUri); } </ins> clear(): void { this._models.forEach(async entry => (await entry.model).dispose()); this._models.clear();