jiebi/CodeConvo huggingface dataset:
Code change:
private _updateActionFromKernelInfo(info: INotebookKernelMatchResult): void { this._kernelDisposable.clear(); this._action.enabled = true; <del> const selectedOrSuggested = info.selected ?? ((info.all.length === 1 && info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </del> <ins> const selectedOrSuggested = info.selected ?? ((info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </ins> if (selectedOrSuggested) { // selected or suggested kernel this._action.label = selectedOrSuggested.label;

Related discussion:
text: Currently in VS Code when users open a notebook document, they don't need to pick a kernel manually only in following two scenarios: The notebook was opened before and users run the notebook against a kernel already. That kernel will be picked automatically, no other kernel would replace it unless users pick one manually. There is only one kernel contributed to this notebook. When users run a cell, and there is still only one kernel, the kernel will be used. Before users run any cell, and there are more than one kernel, the kernel picker will not show any active kernel info (it shows "Select kernel" instead). Above two scenarios cover two use cases: open an existing notebook, or work on single controller notebook (e.g., GitHub issue notebook). However this doesn't cover two common workflow open their existing Jupyter notebook (created through other Jupyter frontend/service) in VS Code create new Jupyter notebooks when they have already specified their preferred kernel Especially that VS Code is still growing to be one of data scientists' Jupyter frontend/editor, almost every new users will run into workflow 1 and do manual kernel picking though often Jupyter has a good guess which kernel is preferred for current document, and also every existing would run into workflow 2. The concrete issues reported: [AZML/Open in VS Code] on AZML website, click open in VS Code, it opens a remote window and opens the notebook document in the editor. No kernel is not picked though users already specify one in AZML website. notebook A in File Explorer, pick a kernel. Create notebook B in File Explorer, the kernel info is back to "Select Kernel" again. untitled notebook in Editor Area, pick a kernel and run. Save as a new notebook document on disk, the new document has no selected kernel. . Create a notebook in JuliaLab, specify a kernel. Open the notebook then in VS Code, preferred kernel not selected. Proposals For AZML/Julia users, they are mostly working on single language notebook (other than polyglot), meaning the notebook serializer is the ipynb extension we ship out of the core, and kernels/controllers are contributed by a single notebook extension installed from the marketplace (Julia, or .NET, or Jupyter). If this is the case, we can pick the kernel whose affinity is the only highest without prompting users to pick one.
Code change:
private _updateActionFromKernelInfo(info: INotebookKernelMatchResult): void { this._kernelDisposable.clear(); this._action.enabled = true; <del> const selectedOrSuggested = info.selected ?? ((info.all.length === 1 && info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </del> <ins> const selectedOrSuggested = info.selected ?? ((info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </ins> if (selectedOrSuggested) { // selected or suggested kernel this._action.label = selectedOrSuggested.label;

Related discussion:
text: cc
Had discussions with about this. In addition to the proposal mentioned above (optimizing the single extension contributing multiple kernels scenario), another idea came out of our discussions: Allow users to choose the default kernel. One example is users have both Jupyter and Julia extensions and both of them contribute notebook controllers for Julia execution. Users might have their preference for the default kernel, allowing them to specify which kernel should be the default can help avoid users picking the default kernel in every newly opened notebook.
I thought about filing a new feature request on this. But it seemed better to keep the discussion contained here, at least for now. In particular it relates to the last comment about selecting a default kernel as well as the Gear icon for the notebook controller. Speaking personally, the majority of my issues with kernel selection would be alleviated by the ability to select a kernel to be my default, auto-selected kernel at both the global level with the ability to override it at the workspace / resource level, just like the rest of VS Code settings. All the rest of selection could work like it currently does. But I want the ownership to be able to explicitly specify kernel selection with some type of manual affordance that always trumps any type of heuristics or metadata or forcing a manual selection. At a surface level I like it as just a setting, but the issue here is that controller IDs are not something that's exposed to the User. The Gear icon might be the right place to surface this, and might have even been what the Gear icon did before (it does nothing now for me in insiders).
Agree 100%. Even though we could save the controller id to settings when users use the gear icon, it's not great as users won't be able to read or tweak this specific setting as the controller ids are not always human readable. With that said, we could tackle this differently to archive the same thing, instead of asking controller id, we could ask users if they want to use the lastly used controller, use a controller suggested by extensions always, use a controller which matches the workspace stats the most (use Julia controller if the workspace stats are all around Julia files).
Yeah, that's the challenge here. Controller ids aren't nice to read and not guaranteed to be constant. A better concept is user state, e.g mementos, which also roam across machines.
Code change:
private _updateActionFromKernelInfo(info: INotebookKernelMatchResult): void { this._kernelDisposable.clear(); this._action.enabled = true; <del> const selectedOrSuggested = info.selected ?? ((info.all.length === 1 && info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </del> <ins> const selectedOrSuggested = info.selected ?? ((info.suggestions.length === 1 && info.suggestions[0].type === NotebookKernelType.Resolved) ? info.suggestions[0] : undefined); </ins> if (selectedOrSuggested) { // selected or suggested kernel this._action.label = selectedOrSuggested.label;

Related discussion:
text: Something already exists but it isn't utilised properly and might need further tweaking. The knows and persists what kernel was used most recently for what . Maybe it's enough to make more brave kernel selections based on that information
Code change:
} }; <ins> if (platform.isWindows) { properties['window.autoDetectHighContrast'] = { 'type': 'boolean', 'default': true, 'description': nls.localize('autoDetectHighContrast', "If enabled, will automatically change to high contrast theme if Windows is using a high contrast theme, and to dark theme when switching away from a Windows high contrast theme."), }; } </ins> if (platform.isMacintosh) { properties['window.titleBarStyle'] = { 'type': 'string',

Related discussion:
text: VSCode Version: 1.8.0 OS Version: Windows Version 6.3.9600 (Windows 8.1 Enterprise) Steps to Reproduce: High Contrast on Windows VS Code, look at the glorious High Contrast theme a different theme, because you would rather work in that VS Code, your theme choice gets overridden. Essentially, I'd like to be able to disable the auto-detection of the High Contrast theme I'm using in Windows via some setting, because while I prefer Windows in High Contrast mode, I dislike looking at VS Code's High Contrast theme.
I wholeheartedly agree. I'm okay with the default being auto-detection, for the accessibility scenario, but it should definitely be possible to disable this functionality via settings.
An option makes sense to me. If someone wants to provide a PR
Done,
Could you please re-open this issue? Unfortunately, my PR only affected the high-contrast swap that occurred when changing Windows theme while VSCode is open, not the initial theme that is set when VSCode starts, or opens a new folder. I have a new PR that completes the fix.
[x] To verify (Windows): Normally VS Code switches to HC mode automatically when windows is running in HC mode. Verify this new setting can be used to prevent this automatic switch from happening (both on startup as well as when Code is running and you change HC mode in Windows).
Code change:
import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle'; import { launchSchemaId } from 'vs/workbench/services/configuration/common/configuration'; import { LoadedScriptsView } from 'vs/workbench/contrib/debug/browser/loadedScriptsView'; <del> import { RunToCursorAction } from 'vs/workbench/contrib/debug/browser/debugEditorActions'; </del> <ins> import { RunToCursorAction, SelectionToReplAction, SelectionToWatchExpressionsAction } from 'vs/workbench/contrib/debug/browser/debugEditorActions'; </ins> import { WatchExpressionsView, ADD_WATCH_LABEL, REMOVE_WATCH_EXPRESSIONS_COMMAND_ID, REMOVE_WATCH_EXPRESSIONS_LABEL, ADD_WATCH_ID } from 'vs/workbench/contrib/debug/browser/watchExpressionsView'; import { VariablesView, SET_VARIABLE_ID, COPY_VALUE_ID, BREAK_WHEN_VALUE_CHANGES_ID, COPY_EVALUATE_PATH_ID, ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, VIEW_MEMORY_ID } from 'vs/workbench/contrib/debug/browser/variablesView'; import { Repl } from 'vs/workbench/contrib/debug/browser/repl';

Related discussion:
text: When I press Ctrl+Shift+P to open the command panel and type "", it shows "No matching commands". So I can't execute this command by Ctrl+Shift+P. I can only bind a shortcut key to this command and then execute it via the shortcut key. I think this is a bug that the command panel search is incomplete.
Please edit this issue title to become:
indicates it may already be there and you just need to know what the command text is.
OK, but according to my observation, there are other commands that cannot be found in the panel. For example, "".
The issue I raised is different from him. His issue is that the shortcut key does not work after binding. My issue is that I can't find the command in the command panel. In fact, some other commands cannot be found, indicating that the search of the command panel is incomplete.
Some commands never appear in the Command Palette because they define their clause as
I open the page where I set the keyboard shortcut and see that their when clause is - not false.
Sorry, I wasn't clear. This is what I am referring to.
I read your link and I probably understand. Please set the when clause of "" to "inDebugMode" instead of false. This is more in line with our needs.
Looks like that command is missing from here: is also missing.
/confirm
I will submit a PR
Thanks!
Code change:
linkAllowedByRules('https://github.com', ['https://github.com/foo/bar', 'https://github.com']); }); <ins> test('ports', () => { linkNotAllowedByRules('https://x.org:8080/foo/bar', ['https://x.org:8081/foo']); linkAllowedByRules('https://x.org:8080/foo/bar', ['https://x.org:*/foo']); linkAllowedByRules('https://x.org/foo/bar', ['https://x.org:*/foo']); linkAllowedByRules('https://x.org:8080/foo/bar', ['https://x.org:8080/foo']); }); test('ip addresses', () => { linkAllowedByRules('http://192.168.1.7/', ['http://192.168.1.7/']); linkAllowedByRules('http://192.168.1.7/', ['http://192.168.1.7']); linkAllowedByRules('http://192.168.1.7/', ['http://192.168.1.*']); linkNotAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.*.6:*']); linkAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.1.7:3000/']); linkAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.1.7:*']); linkAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.1.*:*']); linkNotAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.*.6:*']); }); </ins> test('case normalization', () => { // https://github.com/microsoft/vscode/issues/99294 linkAllowedByRules('https://github.com/microsoft/vscode/issues/new', ['https://github.com/microsoft']);

Related discussion:
text: Issue Type: <bBug</bWrite http://192.168.1.7:3000/ into a text file. Command-click it to try to open the link. You will get an alert asking whether you want to open the external website. Click “Configure Trusted Domains”. <img width="1025" alt="link and dialog asking to confirm opening external website" src="https://user-"Look at the second option in the menu. It says “Trust 1.7:3000 and all its subdomains”. But 1.7:3000 is not a valid address. <img width="1024" alt="link and menu with buggy entry “Trust 1.7:3000 and all its subdomains”" src="https://user-"I can only guess that VS Code thinks that “7” is a TLD and “1.7” is a full domain name. What I actually want to do is whitelist opening all links to IP addresses like . In other words, white-list the subnet . At least, I think that makes sense. But I am not a network engineer, so if it makes more sense to recommend to the user whitelisting some other subnet such as , or whitelisting only the address but on any port, that would be fine too. VS Code version: Code 1.40.1 (, 2019-11-13T16:47:44.719Z) OS version: Darwin x64 18.7.0 <!-- generated by issue reporter --
Code change:
} const focused = this.getFocus(); <del> if (!focused.length) { return this.view.updateElementHeight(index, size, null); } const focus = focused[0]; if (focus <= index) { return this.view.updateElementHeight(index, size, focus); } // the `element` is in the viewport, it's very often that the height update is triggerred by user interaction (collapse, run cell) // then we should make sure that the `element`'s visual view position doesn't change. </del> <ins> const focus = focused.length ? focused[0] : null; </ins> <del> if (this.view.elementTop(index) >= this.view.getScrollTop()) { return this.view.updateElementHeight(index, size, index); </del> <ins> const anchorFocusedSetting = this.configurationService.getValue(NotebookSetting.anchorToFocusedCell); const allowScrolling = this.configurationService.getValue(NotebookSetting.scrollToRevealCell) !== 'none'; const anchorToFocusedCell = anchorFocusedSetting === 'true' || (allowScrolling && anchorFocusedSetting !== 'false'); if (focused && anchorToFocusedCell) { this.view.updateElementHeight(index, size, focus); </ins> } <del> this.view.updateElementHeight(index, size, focus); </del> <ins> this.view.updateElementHeight(index, size, null); </ins> } // override

Related discussion:
text: I think it still works this way out from source in the latest , from what I saw, it's running shift+enter: run cell and move to next This command moves focus to the next cell, so the cell is now the focused cell Then the output of the previous cell (which is no longer focused) starts to grow The change introduced via 's last PR was to ensure that the focused cell stay visually stable, once they are revealed into view can you confirm if this is what you are seeing?
I captured a recording for what probably was comparing, right side is Stable and left side Insiders In both setup, the next cell is fully visible In Stable, shift+enter moves the next cell up, and then push it down, but the new focused cell is still visible in the viewport at the end In Insiders, shift+enter moves the next cell up, and when the previous starts to grow, it does not move the focused cell downwards Even though the new behavior is more self explanatory (from our perspective), but unluckily is not the same as Jupyter Lab. It means we are changing from one custom behavior (our previous heuristics) to another (always keep focused cell stable)
Thanks for clarifying this It was not clear to me that (1) shift+enter and clicking the run cell action did different things, nor that (2) this bug was only about one of these actions.
fixed by
Code change:
} const focused = this.getFocus(); <del> if (!focused.length) { return this.view.updateElementHeight(index, size, null); } const focus = focused[0]; if (focus <= index) { return this.view.updateElementHeight(index, size, focus); } // the `element` is in the viewport, it's very often that the height update is triggerred by user interaction (collapse, run cell) // then we should make sure that the `element`'s visual view position doesn't change. </del> <ins> const focus = focused.length ? focused[0] : null; </ins> <del> if (this.view.elementTop(index) >= this.view.getScrollTop()) { return this.view.updateElementHeight(index, size, index); </del> <ins> const anchorFocusedSetting = this.configurationService.getValue(NotebookSetting.anchorToFocusedCell); const allowScrolling = this.configurationService.getValue(NotebookSetting.scrollToRevealCell) !== 'none'; const anchorToFocusedCell = anchorFocusedSetting === 'true' || (allowScrolling && anchorFocusedSetting !== 'false'); if (focused && anchorToFocusedCell) { this.view.updateElementHeight(index, size, focus); </ins> } <del> this.view.updateElementHeight(index, size, focus); </del> <ins> this.view.updateElementHeight(index, size, null); </ins> } // override

Related discussion:
text: both of these are likely tied to outputLineLimit being large @ 100 when the shift-enter behavior is set to "firstline" the events are as follows: first line of next cell is focused and shown at the bottom of the viewport output is cleared and the focused cell is pulled upwards against the currently executing cell output streams and pushes the focused cell out of the viewport. my ideal thoughts: anchor the focused cell (with setting), maintaining the first line visible. output will stream in, pushing the executing cell upwards out of the viewport shift-enter set to "fullCell" and next cell has a large output focus shifts to next cell, and the viewport exposes the bottom of the output for that cell. there is no cell editor in the viewport my thoughts: "fullCell" behavior should show the top of the next cell editor at the top of the viewport
Code change:
public _serviceBrand: any; <ins> private activePanelContextKey: IContextKey<string>; </ins> private blockOpeningPanel: boolean; private compositeBar: CompositeBar; private compositeActions: { [compositeId: string]: { activityAction: PanelActivityAction, pinnedAction: ToggleCompositePinnedAction } }; private dimension: Dimension; <ins> private disposables: IDisposable[] = []; </ins> constructor( id: string,

Related discussion:
text: I wanted to customize my keybindings depending on the OutputPanel state, but it looks there's no clause to set in the stanza for it.
There is a context , please try that
Ok that works when if focused (but needs to be documented), what about when it's visible?
We accept PRs that update our docs. Checkout the vscode-docs repo. No this is not currently supported, we accept PRs that add this. Code pointers Similar to the viewlet service here The panelPart would add a context key
works but how does a user learn the panel ID?
good point. However we already had that issue with the viewlets, since we already have a "activeViewlet" conext key. We should document this properly
Code change:
private async getAllEditSessions(): Promise<ITreeItem[]> { const allEditSessions = await this.editSessionsStorageService.list(); this.editSessionsCount.set(allEditSessions.length); <del> return allEditSessions.map((session) => { </del> <ins> const editSessions = []; for (const session of allEditSessions) { </ins> const resource = URI.from({ scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${session.ref}` }); <del> return { </del> <ins> const sessionData = await this.editSessionsStorageService.read(session.ref); const label = sessionData?.editSession.folders.map((folder) => folder.name).join(', ') ?? session.ref; const machineId = sessionData?.editSession.machine; const description = machineId === undefined ? fromNow(session.created, true) : `${fromNow(session.created, true)}u00a0u00a0u2022u00a0u00a0${await this.editSessionsStorageService.getMachineById(machineId)}`; editSessions.push({ </ins> handle: resource.toString(), collapsibleState: TreeItemCollapsibleState.Collapsed, <del> label: { label: fromNow(session.created, true) }, description: session.ref, </del> <ins> label: { label }, description: description, </ins> themeIcon: Codicon.repo, contextValue: `edit-session` <del> }; }); </del> <ins> }); } return editSessions; </ins> } private async getEditSession(ref: string): Promise<ITreeItem[]> {

Related discussion:
text: Testing I'm not sure why I have two entries for edit sessions and wonder if it came from another machine/sessions. It would be great to see some metadata about where the source is coming from, similar to the "Synced Data" view for Settings Sync. <img width="394" alt="CleanShot 2022-07-26 at 10 58 31 src="https://user-"<img width="373" alt="CleanShot 2022-07-26 at 11 00 07 src="https://user-"
Code change:
getCommit(ref: string): Promise<Commit>; add(paths: string[]): Promise<void>; <ins> revert(paths: string[]): Promise<void>; </ins> clean(paths: string[]): Promise<void>; apply(patch: string, reverse?: boolean): Promise<void>;

Related discussion:
text: <!-- Do Not Delete This! featurerequesttemplate --<!-- Please read our Rules of Conduct: --<!-- Please search existing issues to avoid creating duplicates. --<!-- Describe the feature you'd like. --The built-in git extension exposes methods for most of the base git operations. Unfortunately not , which would be used to unstage changes. Could easily be to , i'll open a PR for this sometime today.
could you verify this by reviewing
Code change:
invokeProtocolHandler(); <del> // We cannot know whether the protocol handler succeeded. // Display guidance in case it did not, e.g. the app is not installed locally. if (matchesScheme(href, this.productService.urlProtocol)) { </del> <ins> const showProtocolUrlOpenedDialog = async () => { </ins> const showResult = await this.dialogService.show( Severity.Info, localize('openExternalDialogTitle', "All done. You can close this tab now."),

Related discussion:
text: In the following dialog that appears: <img width="696" alt="image" src="https://user-"in and opening a protocol url, the 'Install VS Code Insiders' button should route to a new link for installing insiders specifically rather than just Install VS Code Insiders should not dismiss the dialog, so that the user can return and try again cc
likely a separate issue: Was not sure how this modal was arrived at, so I clicked the remote indicator and I only saw an option to download VS Code - not Insider's as I'd expect. !
I then did the flow and saw the dialogue. Clicking on the button took me to the Insider's download correctly. !