jiebi/CodeConvo huggingface dataset:
} .interactive-session .chat-attached-context { <del> padding: 8px 8px 13px; margin-right: -3px; margin-top: 4px; margin-bottom: -4px; border: 1px solid var(--vscode-input-border, var(--vscode-input-background, transparent)); border-radius: 6px 6px 0px 0px; </del> <ins> padding: 8px 0; border-radius: 6px; </ins> display: flex; gap: 4px; flex-wrap: wrap; } .interactive-session .chat-attached-context .chat-attached-context-attachment { <del> padding: 3px; border: 1px solid var(--vscode-input-border, var(--vscode-input-background, transparent)); </del> <ins> padding: 2px; border: 1px solid var(--vscode-chat-requestBorder, var(--vscode-input-background, transparent)); </ins> border-radius: 5px; <del> height: 20px; </del> <ins> height: 18px; </ins> } .interactive-session-followups {
switch (state) { case VoiceChatSessionState.GettingReady: contextVoiceChatGettingReady.set(true); <del> contextVoiceChatInProgress.set(undefined); </del> <ins> contextVoiceChatInProgress.reset(); </ins> break; case VoiceChatSessionState.Started: <del> contextVoiceChatGettingReady.set(false); </del> <ins> contextVoiceChatGettingReady.reset(); </ins> contextVoiceChatInProgress.set(context); break; case VoiceChatSessionState.Stopped: <del> contextVoiceChatGettingReady.set(false); contextVoiceChatInProgress.set(undefined); </del> <ins> contextVoiceChatGettingReady.reset(); contextVoiceChatInProgress.reset(); </ins> break; } };
f1: true, keybinding: { weight: KeybindingWeight.WorkbenchContrib + 100, <del> primary: KeyCode.Escape </del> <ins> primary: KeyCode.Escape, when: AnyScopedVoiceChatInProgress </ins> }, icon: spinningLoading, precondition: GlobalVoiceChatInProgress, // need global context here because of `f1: true`
disposables.add(controller.onDidHideChat(() => this.stop())); const scopedChatToSpeechInProgress = ScopedChatSynthesisInProgress.bindTo(controller.contextKeyService); <del> disposables.add(toDisposable(() => scopedChatToSpeechInProgress.set(false))); </del> <ins> disposables.add(toDisposable(() => scopedChatToSpeechInProgress.reset())); </ins> disposables.add(session.onDidChange(e => { switch (e.status) {
import { AccessibleViewType, AdvancedContentProvider, ExtensionContentProvider } from 'vs/platform/accessibility/browser/accessibleView'; import { ContextKeyExpression } from 'vs/platform/contextkey/common/contextkey'; import { ServicesAccessor } from 'vs/platform/instantiation/common/instantiation'; <ins> import { alert } from 'vs/base/browser/ui/aria/aria'; </ins> export interface IAccessibleViewImplentation { type: AccessibleViewType;
icon: Codicon.arrowLeft, menu: { ...accessibleViewMenu, <del> when: ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation), </del> <ins> when: ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks), </ins> }, title: localize('editor.action.accessibleViewPreviousCodeBlock', "Accessible View: Previous Code Block") });
*--------------------------------------------------------------------------------------------*/ import * as DOM from '../../../../../../base/browser/dom.js'; <del> import { ICellViewModel } from '../../notebookBrowser.js'; </del> <ins> import { ICellViewModel, INotebookEditorDelegate } from '../../notebookBrowser.js'; </ins> import { CellContentPart } from '../cellPart.js'; export class CellDecorations extends CellContentPart { constructor( <ins> readonly notebookEditor: INotebookEditorDelegate, </ins> readonly rootContainer: HTMLElement, readonly decorationContainer: HTMLElement, ) {
})); generateCellTopDecorations(); <ins> this.registerDecorations(); } private registerDecorations() { if (!this.currentCell) { return; } this.cellDisposables.add(this.currentCell.onCellDecorationsChanged((e) => { e.added.forEach(options => { if (options.className && this.currentCell) { this.rootContainer.classList.add(options.className); this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.className], []); } if (options.outputClassName && this.currentCell) { this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.outputClassName], []); } }); e.removed.forEach(options => { if (options.className && this.currentCell) { this.rootContainer.classList.remove(options.className); this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [], [options.className]); } if (options.outputClassName && this.currentCell) { this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [], [options.outputClassName]); } }); })); this.currentCell.getCellDecorations().forEach(options => { if (options.className && this.currentCell) { this.rootContainer.classList.add(options.className); this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.className], []); } if (options.outputClassName && this.currentCell) { this.notebookEditor.deltaCellContainerClassNames(this.currentCell.id, [options.outputClassName], []); } }); </ins> } }
})); } <del> private registerDecorations() { // Apply decorations this._register(this.viewCell.onCellDecorationsChanged((e) => { e.added.forEach(options => { if (options.className) { this.templateData.rootContainer.classList.add(options.className); } if (options.outputClassName) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.outputClassName], []); } }); e.removed.forEach(options => { if (options.className) { this.templateData.rootContainer.classList.remove(options.className); } if (options.outputClassName) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [], [options.outputClassName]); } }); })); this.viewCell.getCellDecorations().forEach(options => { if (options.className) { this.templateData.rootContainer.classList.add(options.className); } if (options.outputClassName) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.outputClassName], []); } }); } </del> private registerMouseListener() { this._register(this.templateData.editor.onMouseDown(e => { // prevent default on right mouse click, otherwise it will trigger unexpected focus changes
this.templateData.container.classList.toggle('cell-editor-focus', this.viewCell.focusMode === CellFocusMode.Editor); } <del> private applyDecorations() { // apply decorations this._register(this.viewCell.onCellDecorationsChanged((e) => { e.added.forEach(options => { if (options.className) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.className], []); this.templateData.rootContainer.classList.add(options.className); } }); e.removed.forEach(options => { if (options.className) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [], [options.className]); this.templateData.rootContainer.classList.remove(options.className); } }); })); this.viewCell.getCellDecorations().forEach(options => { if (options.className) { this.notebookEditor.deltaCellContainerClassNames(this.viewCell.id, [options.className], []); this.templateData.rootContainer.classList.add(options.className); } }); } </del> override dispose() { this._isDisposed = true;
templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, undefined)), templateDisposables.add(new CellFocusIndicator(this.notebookEditor, titleToolbar, focusIndicatorTop, focusIndicatorLeft, focusIndicatorRight, focusIndicatorBottom)), templateDisposables.add(new FoldedCellHint(this.notebookEditor, DOM.append(container, $('.notebook-folded-hint')), this._notebookExecutionStateService)), <del> templateDisposables.add(new CellDecorations(rootContainer, decorationContainer)), </del> <ins> templateDisposables.add(new CellDecorations(this.notebookEditor, rootContainer, decorationContainer)), </ins> templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)), templateDisposables.add(new CollapsedCellInput(this.notebookEditor, cellInputCollapsedContainer)), templateDisposables.add(new CellFocusPart(container, undefined, this.notebookEditor)),
templateDisposables.add(scopedInstaService.createInstance(CellChatPart, this.notebookEditor, cellChatPart)), templateDisposables.add(scopedInstaService.createInstance(CellEditorStatusBar, this.notebookEditor, container, editorPart, editor)), templateDisposables.add(scopedInstaService.createInstance(CellProgressBar, editorPart, cellInputCollapsedContainer)), <del> templateDisposables.add(new CellDecorations(rootContainer, decorationContainer)), </del> <ins> templateDisposables.add(new CellDecorations(this.notebookEditor, rootContainer, decorationContainer)), </ins> templateDisposables.add(scopedInstaService.createInstance(CellComments, this.notebookEditor, cellCommentPartContainer)), templateDisposables.add(scopedInstaService.createInstance(CellExecutionPart, this.notebookEditor, executionOrderLabel)), templateDisposables.add(scopedInstaService.createInstance(CollapsedCellOutput, this.notebookEditor, cellOutputCollapsedContainer)),
const file = this.extHostFileSystemInfo.extUri.joinPath(outputDir, `${this.namePool++}-${name.replace(/[/:*?"<>|]/g, '')}.log`); const logger = this.loggerService.createLogger(file, { logLevel: 'always', donotRotate: true, donotUseFormatters: true, hidden: true }); const id = await this.proxy.$register(name, file, languageId, extension.identifier.value); <del> return new ExtHostOutputChannel(id, name, logger, this.proxy, extension); </del> <ins> return new ExtHostOutputChannel(id, name, file, logger, this.proxy, extension); </ins> } private async doCreateLogOutputChannel(name: string, logLevel: LogLevel | undefined, extension: IExtensionDescription): Promise<ExtHostLogOutputChannel> {
const file = this.extHostFileSystemInfo.extUri.joinPath(extensionLogDir, `${fileName}.log`); const id = `${extension.identifier.value}.${fileName}`; const logger = this.loggerService.createLogger(file, { id, name, logLevel, extensionId: extension.identifier.value }); <del> return new ExtHostLogOutputChannel(id, name, logger, this.proxy, extension); </del> <ins> return new ExtHostLogOutputChannel(id, name, file, logger, this.proxy, extension); </ins> } private createExtensionLogDirectory(extension: IExtensionDescription): Thenable<URI> {
onDidChangeLogLevel.fire(newLogLevel); } channelPromise.then(channel => { <del> disposables.add(channel); </del> if (channel.logLevel !== logLevel) { setLogLevel(channel.logLevel); } disposables.add(channel.onDidChangeLogLevel(e => setLogLevel(e))); }); <ins> const outputChannel = this.createExtHostOutputChannel(name, channelPromise); </ins> return { <del> ...this.createExtHostOutputChannel(name, channelPromise), </del> <ins> ...outputChannel, </ins> get logLevel() { return logLevel; }, onDidChangeLogLevel: onDidChangeLogLevel.event, trace(value: string, ...args: any[]): void {
public getEditOperations(model: ITextModel, builder: IEditOperationBuilder): void { <ins> const getLanguageId = () => { return model.getLanguageId(); }; const getLanguageIdAtPosition = (lineNumber: number, column: number) => { return model.getLanguageIdAtPosition(lineNumber, column); }; </ins> const modelLineCount = model.getLineCount(); if (this._isMovingDown && this._selection.endLineNumber === modelLineCount) {
const { tabSize, indentSize, insertSpaces } = model.getOptions(); const indentConverter = this.buildIndentConverter(tabSize, indentSize, insertSpaces); <del> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { return model.tokenization.getLineTokens(lineNumber); }, getLanguageId: () => { return model.getLanguageId(); }, getLanguageIdAtPosition: (lineNumber: number, column: number) => { return model.getLanguageIdAtPosition(lineNumber, column); }, }, getLineContent: null as unknown as (lineNumber: number) => string, }; </del> if (s.startLineNumber === s.endLineNumber && model.getLineMaxColumn(s.startLineNumber) === 1) { // Current line is empty
insertingText = newIndentation + this.trimStart(movingLineText); } else { // no enter rule matches, let's check indentatin rules then. <del> virtualModel.getLineContent = (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.getLineContent(movingLineNumber); } else { return model.getLineContent(lineNumber); } </del> <ins> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.tokenization.getLineTokens(movingLineNumber); } else { return model.tokenization.getLineTokens(lineNumber); } }, getLanguageId, getLanguageIdAtPosition, }, getLineContent: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.getLineContent(movingLineNumber); } else { return model.getLineContent(lineNumber); } }, </ins> }; const indentOfMovingLine = getGoodIndentForLine( this._autoIndent,
} } else { // it doesn't match onEnter rules, let's check indentation rules then. <del> virtualModel.getLineContent = (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return insertingText; } else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) { return model.getLineContent(lineNumber - 1); } else { return model.getLineContent(lineNumber); } </del> <ins> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return model.tokenization.getLineTokens(movingLineNumber); } else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) { return model.tokenization.getLineTokens(lineNumber - 1); } else { return model.tokenization.getLineTokens(lineNumber); } }, getLanguageId, getLanguageIdAtPosition, }, getLineContent: (lineNumber: number) => { if (lineNumber === s.startLineNumber) { return insertingText; } else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) { return model.getLineContent(lineNumber - 1); } else { return model.getLineContent(lineNumber); } }, </ins> }; const newIndentatOfMovingBlock = getGoodIndentForLine(
builder.addEditOperation(new Range(s.endLineNumber, model.getLineMaxColumn(s.endLineNumber), s.endLineNumber, model.getLineMaxColumn(s.endLineNumber)), 'n' + movingLineText); if (this.shouldAutoIndent(model, s)) { <del> virtualModel.getLineContent = (lineNumber: number) => { if (lineNumber === movingLineNumber) { return model.getLineContent(s.startLineNumber); } else { return model.getLineContent(lineNumber); } </del> <ins> const virtualModel: IVirtualModel = { tokenization: { getLineTokens: (lineNumber: number) => { if (lineNumber === movingLineNumber) { return model.tokenization.getLineTokens(s.startLineNumber); } else { return model.tokenization.getLineTokens(lineNumber); } }, getLanguageId, getLanguageIdAtPosition, }, getLineContent: (lineNumber: number) => { if (lineNumber === movingLineNumber) { return model.getLineContent(s.startLineNumber); } else { return model.getLineContent(lineNumber); } }, </ins> }; const ret = this.matchEnterRule(model, indentConverter, tabSize, s.startLineNumber, s.startLineNumber - 2);
'enumItemLabels': languagesSorted.map(key => languages[key].name) }, [AccessibilityVoiceSettingId.AutoSynthesize]: { <del> 'type': 'boolean', </del> <ins> 'type': 'string', 'enum': ['on', 'off', 'auto'], 'enumDescriptions': [ localize('accessibility.voice.autoSynthesize.on', "Enable the feature. When a screen reader is enabled, note that this will disable aria updates."), localize('accessibility.voice.autoSynthesize.off', "Disable the feature."), localize('accessibility.voice.autoSynthesize.auto', "When a screen reader is detected, disable the feature. Otherwise, enable the feature.") ], </ins> 'markdownDescription': localize('autoSynthesize', "Whether a textual response should automatically be read out aloud when speech was used as input. For example in a chat session, a response is automatically synthesized when voice was used as chat request."), <del> 'default': this.productService.quality !== 'stable', // TODO@bpasero decide on a default </del> <ins> 'default': this.productService.quality !== 'stable' ? 'auto' : 'off', // TODO@bpasero decide on a default </ins> 'tags': ['accessibility'] } }
Registry.as<IConfigurationMigrationRegistry>(WorkbenchExtensions.ConfigurationMigration) .registerConfigurationMigrations([{ <ins> key: AccessibilityVoiceSettingId.AutoSynthesize, migrateFn: (value: boolean) => { let newValue: string | undefined; if (value === true) { newValue = 'on'; } else if (value === false) { newValue = 'off'; } return [ [AccessibilityVoiceSettingId.AutoSynthesize, { value: newValue }], ]; } }]); Registry.as<IConfigurationMigrationRegistry>(WorkbenchExtensions.ConfigurationMigration) .registerConfigurationMigrations([{ </ins> key: 'accessibility.signals.chatResponsePending', migrateFn: (value, accessor) => { return [
import { IChatResponseViewModel } from 'vs/workbench/contrib/chat/common/chatViewModel'; import { renderStringAsPlaintext } from 'vs/base/browser/markdownRenderer'; import { MarkdownString } from 'vs/base/common/htmlContent'; <ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; import { AccessibilityVoiceSettingId } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; </ins> const CHAT_RESPONSE_PENDING_ALLOWANCE_MS = 4000; export class ChatAccessibilityService extends Disposable implements IChatAccessibilityService {
private _requestId: number = 0; <del> constructor(@IAccessibilitySignalService private readonly _accessibilitySignalService: IAccessibilitySignalService, @IInstantiationService private readonly _instantiationService: IInstantiationService) { </del> <ins> constructor( @IAccessibilitySignalService private readonly _accessibilitySignalService: IAccessibilitySignalService, @IInstantiationService private readonly _instantiationService: IInstantiationService, @IConfigurationService private readonly _configurationService: IConfigurationService ) { </ins> super(); } acceptRequest(): number {
} const errorDetails = isPanelChat && response.errorDetails ? ` ${response.errorDetails.message}` : ''; const plainTextResponse = renderStringAsPlaintext(new MarkdownString(responseContent)); <del> status(plainTextResponse + errorDetails); </del> <ins> if (this._configurationService.getValue(AccessibilityVoiceSettingId.AutoSynthesize) !== 'on') { status(plainTextResponse + errorDetails); } </ins> } }
if (!response) { return; } <del> if ( !this.accessibilityService.isScreenReaderOptimized() && // do not auto synthesize when screen reader is active this.configurationService.getValue<boolean>(AccessibilityVoiceSettingId.AutoSynthesize) === true ) { </del> <ins> const autoSynthesize = this.configurationService.getValue<'on' | 'off' | 'auto'>(AccessibilityVoiceSettingId.AutoSynthesize); if (autoSynthesize === 'on' || autoSynthesize === 'auto' && !this.accessibilityService.isScreenReaderOptimized()) { </ins> let context: IVoiceChatSessionController | 'focused'; if (controller.context === 'inline') { // TODO@bpasero this is ugly, but the lightweight inline chat turns into
throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", this.manifest.displayName || this.manifest.name)); } } <del> } else { // Remove the extension with same version if it is already uninstalled. // Installing a VSIX extension shall replace the existing extension always. const existingWithSameVersion = await this.unsetIfUninstalled(this.extensionKey); if (existingWithSameVersion) { try { await this.extensionsScanner.removeExtension(existingWithSameVersion, 'existing'); } catch (e) { throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", this.manifest.displayName || this.manifest.name)); } </del> <ins> } // Remove the extension with same version if it is already uninstalled. // Installing a VSIX extension shall replace the existing extension always. const existingWithSameVersion = await this.unsetIfUninstalled(this.extensionKey); if (existingWithSameVersion) { try { await this.extensionsScanner.removeExtension(existingWithSameVersion, 'existing'); } catch (e) { throw new Error(nls.localize('restartCode', "Please restart VS Code before reinstalling {0}.", this.manifest.displayName || this.manifest.name)); </ins> } }
if (items && items.length > 0) { this.followupsDisposables.add(this.instantiationService.createInstance<typeof ChatFollowups<IChatFollowup>, ChatFollowups<IChatFollowup>>(ChatFollowups, this.followupsContainer, items, this.location, undefined, followup => this._onDidAcceptFollowup.fire({ followup, response }))); } <ins> this._onDidChangeHeight.fire(); </ins> } get contentHeight(): number {
this._store.add(this._widget); this._widget.render(this._inputContainer); this._widget.setModel(this._defaultChatModel, {}); <del> this._store.add(this._widget.inputEditor.onDidContentSizeChange(() => _editor.layoutContentWidget(this))); </del> <ins> this._store.add(this._widget.onDidChangeContentHeight(() => _editor.layoutContentWidget(this))); </ins> this._domNode.tabIndex = -1; this._domNode.className = 'inline-chat-content-widget interactive-session';
{ "name": "code-oss-dev", "version": "1.91.0", <del> "distro": "170beceb9849568b8f7159757bc3fc3964af1986", </del> <ins> "distro": "361fc45f5932b161db29080d5b19bc5afb9baae6", </ins> "author": { "name": "Microsoft Corporation" },
apps: @@NAME@@: <del> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ </del> <ins> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ --no-sandbox </ins> common-id: @@NAME@@.desktop url-handler: <del> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ --open-url </del> <ins> command: electron-launch $SNAP/usr/share/@@NAME@@/bin/@@NAME@@ --open-url --no-sandbox </ins>
} set statusBarCommands(statusBarCommands: vscode.Command[] | undefined) { <del> this.logService.info('ExtHostSourceControl#statusBarCommands', (statusBarCommands ?? []).map(c => c.command).join(', ')); </del> <ins> this.logService.trace('ExtHostSourceControl#statusBarCommands', (statusBarCommands ?? []).map(c => c.command).join(', ')); </ins> if (this._statusBarCommands && statusBarCommands && commandListEquals(this._statusBarCommands, statusBarCommands)) { <del> this.logService.info('ExtHostSourceControl#statusBarCommands are equal'); </del> <ins> this.logService.trace('ExtHostSourceControl#statusBarCommands are equal'); </ins> return; }
const visibleRanges = editor.getVisibleRanges(); if (visibleRanges.length > 0) { visiblePosition = visibleRanges[0].getStartPosition(); <ins> const cursorPos = editor.getPosition(); if (cursorPos) { const isVisible = visibleRanges.some(range => range.containsPosition(cursorPos)); if (isVisible) { // Keep cursor pos fixed if it is visible visiblePosition = cursorPos; } } </ins> const visiblePositionScrollTop = editor.getTopForPosition(visiblePosition.lineNumber, visiblePosition.column); visiblePositionScrollDelta = editor.getScrollTop() - visiblePositionScrollTop; }
this._viewsService.openView(Markers.MARKERS_VIEW_ID); } else if (task.command.presentation && (task.command.presentation.focus || task.command.presentation.reveal === RevealKind.Always)) { this._terminalService.setActiveInstance(terminal); <del> await this._terminalService.revealActiveTerminal(); </del> <ins> await this._terminalService.revealTerminal(terminal); </ins> if (task.command.presentation.focus) { <del> this._terminalService.focusActiveInstance(); </del> <ins> this._terminalService.focusInstance(terminal); </ins> } } this._activeTasks[task.getMapKey()].terminal = terminal;
getReconnectedTerminals(reconnectionOwner: string): ITerminalInstance[] | undefined; getActiveOrCreateInstance(options?: { acceptsInput?: boolean }): Promise<ITerminalInstance>; <ins> revealTerminal(source: ITerminalInstance, preserveFocus?: boolean): Promise<void>; </ins> revealActiveTerminal(preserveFocus?: boolean): Promise<void>; moveToEditor(source: ITerminalInstance, group?: GroupIdentifier | SIDE_GROUP_TYPE | ACTIVE_GROUP_TYPE | AUX_WINDOW_GROUP_TYPE): void; moveIntoNewEditor(source: ITerminalInstance): void;