@codingame/monaco-vscode-telemetry-service-override 32.0.1 → 33.0.9

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/arcTelemetryReporter.js

@@ -0,0 +1,80 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { TimeoutTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { BaseStringEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ArcTracker } from '../../common/arcTracker.js';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+let ArcTelemetryReporter = class ArcTelemetryReporter extends Disposable {
+    constructor(
+        _timesMs,
+        _documentValueBeforeTrackedEdit,
+        _document,
+        _gitRepo,
+        _trackedEdit,
+        _sendTelemetryEvent,
+        _dispose,
+        _telemetryService
+    ) {
+        super();
+        this._timesMs = _timesMs;
+        this._documentValueBeforeTrackedEdit = _documentValueBeforeTrackedEdit;
+        this._document = _document;
+        this._gitRepo = _gitRepo;
+        this._trackedEdit = _trackedEdit;
+        this._sendTelemetryEvent = _sendTelemetryEvent;
+        this._dispose = _dispose;
+        this._telemetryService = _telemetryService;
+        this._arcTracker = ( new ArcTracker(this._documentValueBeforeTrackedEdit, this._trackedEdit));
+        this._store.add(runOnChange(this._document.value, (_val, _prevVal, changes) => {
+            const edit = BaseStringEdit.composeOrUndefined(( changes.map(c => c.edit)));
+            if (edit) {
+                this._arcTracker.handleEdits(edit);
+            }
+        }));
+        this._initialLineCounts = this._arcTracker.getLineCountInfo();
+        this._initialBranchName = this._gitRepo.get()?.headBranchNameObs.get();
+        for (let i = 0; i < this._timesMs.length; i++) {
+            const timeMs = this._timesMs[i];
+            if (timeMs <= 0) {
+                this._report(timeMs);
+            } else {
+                this._reportAfter(timeMs, i === this._timesMs.length - 1 ? () => {
+                    this._dispose();
+                } : undefined);
+            }
+        }
+    }
+    _reportAfter(timeoutMs, cb) {
+        const timer = new TimeoutTimer(() => {
+            this._report(timeoutMs);
+            timer.dispose();
+            if (cb) {
+                cb();
+            }
+        }, timeoutMs);
+        this._store.add(timer);
+    }
+    _report(timeMs) {
+        const currentBranch = this._gitRepo.get()?.headBranchNameObs.get();
+        const didBranchChange = currentBranch !== this._initialBranchName;
+        const currentLineCounts = this._arcTracker.getLineCountInfo();
+        this._sendTelemetryEvent({
+            telemetryService: this._telemetryService,
+            timeDelayMs: timeMs,
+            didBranchChange,
+            arc: this._arcTracker.getAcceptedRestrainedCharactersCount(),
+            originalCharCount: this._arcTracker.getOriginalCharacterCount(),
+            currentLineCount: currentLineCounts.insertedLineCounts,
+            currentDeletedLineCount: currentLineCounts.deletedLineCounts,
+            originalLineCount: this._initialLineCounts.insertedLineCounts,
+            originalDeletedLineCount: this._initialLineCounts.deletedLineCounts
+        });
+    }
+};
+ArcTelemetryReporter = ( __decorate([( __param(7, ITelemetryService))], ArcTelemetryReporter));
+
+export { ArcTelemetryReporter };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/arcTelemetrySender.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { EditSourceData, IDocumentWithAnnotatedEdits } from "../helpers/documentWithAnnotatedEdits.js";
+import { IAiEditTelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/telemetry/aiEditTelemetry/aiEditTelemetryService.service";
+import type { ScmRepoAdapter } from "./scmAdapter.js";
+import { IRandomService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service";
+export declare class EditTelemetryReportInlineEditArcSender extends Disposable {
+    private readonly _instantiationService;
+    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, scmRepoBridge: IObservable<ScmRepoAdapter | undefined>, _instantiationService: IInstantiationService);
+}
+export declare class CreateSuggestionIdForChatOrInlineChatCaller extends Disposable {
+    private readonly _aiEditTelemetryService;
+    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, _aiEditTelemetryService: IAiEditTelemetryService);
+}
+export declare class EditTelemetryReportEditArcForChatOrInlineChatSender extends Disposable {
+    private readonly _instantiationService;
+    private readonly _randomService;
+    constructor(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, scmRepoBridge: IObservable<ScmRepoAdapter | undefined>, _instantiationService: IInstantiationService, _randomService: IRandomService);
+}

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/arcTelemetrySender.js

@@ -0,0 +1,173 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { AnnotatedStringEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit';
+import { EditDeltaInfo } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { createDocWithJustReason } from '../helpers/documentWithAnnotatedEdits.js';
+import { IAiEditTelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/telemetry/aiEditTelemetry/aiEditTelemetryService.service';
+import { forwardToChannelIf, isCopilotLikeExtension } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/browser/forwardingTelemetryService';
+import { ProviderId } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ArcTelemetryReporter } from './arcTelemetryReporter.js';
+import { IRandomService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+let EditTelemetryReportInlineEditArcSender = class EditTelemetryReportInlineEditArcSender extends Disposable {
+    constructor(docWithAnnotatedEdits, scmRepoBridge, _instantiationService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._register(runOnChange(docWithAnnotatedEdits.value, (_val, _prev, changes) => {
+            const edit = AnnotatedStringEdit.compose(( changes.map(c => c.edit)));
+            if (!( edit.replacements.some(r => r.data.editSource.metadata.source === "inlineCompletionAccept"))) {
+                return;
+            }
+            if (!edit.replacements.every(r => r.data.editSource.metadata.source === "inlineCompletionAccept")) {
+                onUnexpectedError(( new Error("ArcTelemetrySender: Not all edits are inline completion accept edits!")));
+                return;
+            }
+            if (edit.replacements[0].data.editSource.metadata.source !== "inlineCompletionAccept") {
+                return;
+            }
+            const data = edit.replacements[0].data.editSource.metadata;
+            const docWithJustReason = createDocWithJustReason(docWithAnnotatedEdits, this._store);
+            const reporter = this._store.add(
+                this._instantiationService.createInstance(ArcTelemetryReporter, ( [0, 30, 120, 300, 600, 900].map(s => s * 1000)), _prev, docWithJustReason, scmRepoBridge, edit, res => {
+                    res.telemetryService.publicLog2("editTelemetry.reportInlineEditArc", {
+                        extensionId: data.$extensionId ?? "",
+                        extensionVersion: data.$extensionVersion ?? "",
+                        opportunityId: data.$$requestUuid ?? "unknown",
+                        languageId: data.$$languageId,
+                        correlationId: data.$$correlationId,
+                        didBranchChange: res.didBranchChange ? 1 : 0,
+                        timeDelayMs: res.timeDelayMs,
+                        originalCharCount: res.originalCharCount,
+                        originalLineCount: res.originalLineCount,
+                        originalDeletedLineCount: res.originalDeletedLineCount,
+                        arc: res.arc,
+                        currentLineCount: res.currentLineCount,
+                        currentDeletedLineCount: res.currentDeletedLineCount,
+                        ...forwardToChannelIf(isCopilotLikeExtension(data.$extensionId))
+                    });
+                }, () => {
+                    this._store.delete(reporter);
+                })
+            );
+        }));
+    }
+};
+EditTelemetryReportInlineEditArcSender = ( __decorate([( __param(2, IInstantiationService))], EditTelemetryReportInlineEditArcSender));
+let CreateSuggestionIdForChatOrInlineChatCaller = class CreateSuggestionIdForChatOrInlineChatCaller extends Disposable {
+    constructor(docWithAnnotatedEdits, _aiEditTelemetryService) {
+        super();
+        this._aiEditTelemetryService = _aiEditTelemetryService;
+        this._register(runOnChange(docWithAnnotatedEdits.value, (_val, _prev, changes) => {
+            const edit = AnnotatedStringEdit.compose(( changes.map(c => c.edit)));
+            const supportedSource = ( new Set(["Chat.applyEdits", "inlineChat.applyEdits"]));
+            if (!( edit.replacements.some(r => ( supportedSource.has(r.data.editSource.metadata.source))))) {
+                return;
+            }
+            if (!edit.replacements.every(r => ( supportedSource.has(r.data.editSource.metadata.source)))) {
+                onUnexpectedError(( new Error(
+                    `ArcTelemetrySender: Not all edits are ${edit.replacements[0].data.editSource.metadata.source}!`
+                )));
+                return;
+            }
+            let applyCodeBlockSuggestionId = undefined;
+            const data = edit.replacements[0].data.editSource;
+            let feature;
+            if (data.metadata.source === "Chat.applyEdits") {
+                feature = "sideBarChat";
+                if (data.metadata.$$mode === "applyCodeBlock") {
+                    applyCodeBlockSuggestionId = data.metadata.$$codeBlockSuggestionId;
+                }
+            } else {
+                feature = "inlineChat";
+            }
+            const providerId = ( new ProviderId(
+                data.props.$extensionId,
+                data.props.$extensionVersion,
+                data.props.$providerId
+            ));
+            this._aiEditTelemetryService.createSuggestionId({
+                applyCodeBlockSuggestionId,
+                languageId: data.props.$$languageId,
+                presentation: "highlightedEdit",
+                feature,
+                source: providerId,
+                modelId: data.props.$modelId,
+                modeId: data.props.$$mode,
+                editDeltaInfo: EditDeltaInfo.fromEdit(edit, _prev),
+                sourceRequestId: undefined
+            });
+        }));
+    }
+};
+CreateSuggestionIdForChatOrInlineChatCaller = ( __decorate([( __param(1, IAiEditTelemetryService))], CreateSuggestionIdForChatOrInlineChatCaller));
+let EditTelemetryReportEditArcForChatOrInlineChatSender = class EditTelemetryReportEditArcForChatOrInlineChatSender extends Disposable {
+    constructor(
+        docWithAnnotatedEdits,
+        scmRepoBridge,
+        _instantiationService,
+        _randomService
+    ) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._randomService = _randomService;
+        this._register(runOnChange(docWithAnnotatedEdits.value, (_val, _prev, changes) => {
+            const edit = AnnotatedStringEdit.compose(( changes.map(c => c.edit)));
+            const supportedSource = ( new Set(["Chat.applyEdits", "inlineChat.applyEdits"]));
+            if (!( edit.replacements.some(r => ( supportedSource.has(r.data.editSource.metadata.source))))) {
+                return;
+            }
+            if (!edit.replacements.every(r => ( supportedSource.has(r.data.editSource.metadata.source)))) {
+                onUnexpectedError(( new Error(
+                    `ArcTelemetrySender: Not all edits are ${edit.replacements[0].data.editSource.metadata.source}!`
+                )));
+                return;
+            }
+            const data = edit.replacements[0].data.editSource;
+            const uniqueEditId = this._randomService.generateUuid();
+            const docWithJustReason = createDocWithJustReason(docWithAnnotatedEdits, this._store);
+            const reporter = this._store.add(
+                this._instantiationService.createInstance(ArcTelemetryReporter, ( [0, 60, 300].map(s => s * 1000)), _prev, docWithJustReason, scmRepoBridge, edit, res => {
+                    res.telemetryService.publicLog2("editTelemetry.reportEditArc", {
+                        sourceKeyCleaned: data.toKey(Number.MAX_SAFE_INTEGER, {
+                            $extensionId: false,
+                            $extensionVersion: false,
+                            $$requestUuid: false,
+                            $$sessionId: false,
+                            $$requestId: false,
+                            $$languageId: false,
+                            $modelId: false
+                        }),
+                        extensionId: data.props.$extensionId,
+                        extensionVersion: data.props.$extensionVersion,
+                        opportunityId: data.props.$$requestUuid,
+                        editSessionId: data.props.$$sessionId,
+                        requestId: data.props.$$requestId,
+                        modelId: data.props.$modelId,
+                        languageId: data.props.$$languageId,
+                        mode: data.props.$$mode,
+                        uniqueEditId,
+                        didBranchChange: res.didBranchChange ? 1 : 0,
+                        timeDelayMs: res.timeDelayMs,
+                        originalCharCount: res.originalCharCount,
+                        originalLineCount: res.originalLineCount,
+                        originalDeletedLineCount: res.originalDeletedLineCount,
+                        arc: res.arc,
+                        currentLineCount: res.currentLineCount,
+                        currentDeletedLineCount: res.currentDeletedLineCount,
+                        ...forwardToChannelIf(isCopilotLikeExtension(data.props.$extensionId))
+                    });
+                }, () => {
+                    this._store.delete(reporter);
+                })
+            );
+        }));
+    }
+};
+EditTelemetryReportEditArcForChatOrInlineChatSender = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IRandomService))], EditTelemetryReportEditArcForChatOrInlineChatSender));
+
+export { CreateSuggestionIdForChatOrInlineChatCaller, EditTelemetryReportEditArcForChatOrInlineChatSender, EditTelemetryReportInlineEditArcSender };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editSourceTrackingFeature.d.ts

@@ -0,0 +1,23 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IStatusbarService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar.service";
+import { IAnnotatedDocuments } from "../helpers/annotatedDocuments.js";
+import { VSCodeWorkspace } from "../helpers/vscodeObservableWorkspace.js";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+export declare class EditTrackingFeature extends Disposable {
+    private readonly _workspace;
+    private readonly _annotatedDocuments;
+    private readonly _configurationService;
+    private readonly _instantiationService;
+    private readonly _statusbarService;
+    private readonly _editorService;
+    private readonly _extensionService;
+    private readonly _editSourceTrackingShowDecorations;
+    private readonly _editSourceTrackingShowStatusBar;
+    private readonly _showStateInMarkdownDoc;
+    private readonly _toggleDecorations;
+    constructor(_workspace: VSCodeWorkspace, _annotatedDocuments: IAnnotatedDocuments, _configurationService: IConfigurationService, _instantiationService: IInstantiationService, _statusbarService: IStatusbarService, _editorService: IEditorService, _extensionService: IExtensionService);
+    private _createEditSourceAgenda;
+}

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editSourceTrackingFeature.js

@@ -0,0 +1,232 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CachedFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cache';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { DynamicCssRules } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorDom';
+import { observableCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/observableCodeEditor';
+import { CodeEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { StatusbarAlignment } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar';
+import { IStatusbarService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
+import { EditSourceTrackingImpl } from './editSourceTrackingImpl.js';
+import { DataChannelForwardingTelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/browser/forwardingTelemetryService';
+import { EDIT_TELEMETRY_SHOW_DECORATIONS, EDIT_TELEMETRY_SHOW_STATUS_BAR, EDIT_TELEMETRY_DETAILS_SETTING_ID } from '../settings.js';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { derived, derivedWithSetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { mapObservableArrayCached } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+let EditTrackingFeature = class EditTrackingFeature extends Disposable {
+    constructor(
+        _workspace,
+        _annotatedDocuments,
+        _configurationService,
+        _instantiationService,
+        _statusbarService,
+        _editorService,
+        _extensionService
+    ) {
+        super();
+        this._workspace = _workspace;
+        this._annotatedDocuments = _annotatedDocuments;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._statusbarService = _statusbarService;
+        this._editorService = _editorService;
+        this._extensionService = _extensionService;
+        this._showStateInMarkdownDoc = "editTelemetry.showDebugDetails";
+        this._toggleDecorations = "editTelemetry.toggleDebugDecorations";
+        this._editSourceTrackingShowDecorations = makeSettable(
+            observableConfigValue(EDIT_TELEMETRY_SHOW_DECORATIONS, false, this._configurationService)
+        );
+        this._editSourceTrackingShowStatusBar = observableConfigValue(EDIT_TELEMETRY_SHOW_STATUS_BAR, false, this._configurationService);
+        const editSourceDetailsEnabled = observableConfigValue(EDIT_TELEMETRY_DETAILS_SETTING_ID, false, this._configurationService);
+        const extensions = observableFromEvent(this._extensionService.onDidChangeExtensions, () => {
+            return this._extensionService.extensions;
+        });
+        const extensionIds = derived(reader => ( new Set(( extensions.read(reader).map(e => e.id?.toLowerCase())))));
+        function getExtensionInfoObs(extensionId, extensionService) {
+            const extIdLowerCase = extensionId.toLowerCase();
+            return derived(reader => ( extensionIds.read(reader).has(extIdLowerCase)));
+        }
+        const copilotInstalled = getExtensionInfoObs("GitHub.copilot");
+        const copilotChatInstalled = getExtensionInfoObs("GitHub.copilot-chat");
+        const shouldSendDetails = derived(
+            reader => editSourceDetailsEnabled.read(reader) || !!copilotInstalled.read(reader) || !!copilotChatInstalled.read(reader)
+        );
+        const instantiationServiceWithInterceptedTelemetry = this._instantiationService.createChild(( new ServiceCollection([
+            ITelemetryService,
+            this._instantiationService.createInstance(DataChannelForwardingTelemetryService)
+        ])));
+        const impl = this._register(
+            instantiationServiceWithInterceptedTelemetry.createInstance(EditSourceTrackingImpl, shouldSendDetails, this._annotatedDocuments)
+        );
+        this._register(autorun(reader => {
+            if (!this._editSourceTrackingShowDecorations.read(reader)) {
+                return;
+            }
+            const visibleEditors = observableFromEvent(
+                this,
+                this._editorService.onDidVisibleEditorsChange,
+                () => this._editorService.visibleTextEditorControls
+            );
+            mapObservableArrayCached(this, visibleEditors, (editor, store) => {
+                if (editor instanceof CodeEditorWidget) {
+                    const obsEditor = observableCodeEditor(editor);
+                    const cssStyles = ( new DynamicCssRules(editor));
+                    const decorations = ( new CachedFunction(source => {
+                        const r = store.add(cssStyles.createClassNameRef({
+                            backgroundColor: source.getColor()
+                        }));
+                        return r.className;
+                    }));
+                    store.add(obsEditor.setDecorations(derived(reader => {
+                        const uri = obsEditor.model.read(reader)?.uri;
+                        if (!uri) {
+                            return [];
+                        }
+                        const doc = this._workspace.getDocument(uri);
+                        if (!doc) {
+                            return [];
+                        }
+                        const docsState = impl.docsState.read(reader).get(doc);
+                        if (!docsState) {
+                            return [];
+                        }
+                        const ranges = (docsState.longtermTracker.read(reader)?.getTrackedRanges(reader)) ?? [];
+                        return ( ranges.map(r => ({
+                            range: doc.value.read(undefined).getTransformer().getRange(r.range),
+                            options: {
+                                description: "editSourceTracking",
+                                inlineClassName: decorations.get(r.source)
+                            }
+                        })));
+                    })));
+                }
+            }).recomputeInitiallyAndOnChange(reader.store);
+        }));
+        this._register(autorun(reader => {
+            if (!this._editSourceTrackingShowStatusBar.read(reader)) {
+                return;
+            }
+            const statusBarItem = reader.store.add(this._statusbarService.addEntry({
+                name: "",
+                text: "",
+                command: this._showStateInMarkdownDoc,
+                tooltip: "Edit Source Tracking",
+                ariaLabel: ""
+            }, "editTelemetry", StatusbarAlignment.RIGHT, 100));
+            const sumChangedCharacters = derived(reader => {
+                const docs = impl.docsState.read(reader);
+                let sum = 0;
+                for (const state of ( docs.values())) {
+                    const t = state.longtermTracker.read(reader);
+                    if (!t) {
+                        continue;
+                    }
+                    const d = state.getTelemetryData(t.getTrackedRanges(reader));
+                    sum += d.totalModifiedCharactersInFinalState;
+                }
+                return sum;
+            });
+            const tooltipMarkdownString = derived(reader => {
+                const docs = impl.docsState.read(reader);
+                const docsDataInTooltip = [];
+                const editSources = [];
+                for (const [doc, state] of docs) {
+                    const tracker = state.longtermTracker.read(reader);
+                    if (!tracker) {
+                        continue;
+                    }
+                    const trackedRanges = tracker.getTrackedRanges(reader);
+                    const data = state.getTelemetryData(trackedRanges);
+                    if (data.totalModifiedCharactersInFinalState === 0) {
+                        continue;
+                    }
+                    editSources.push(...( trackedRanges.map(r => r.source)));
+                    const filteredData = Object.fromEntries(
+                        Object.entries(data).filter(([_, value]) => !(typeof value === "number") || value !== 0)
+                    );
+                    docsDataInTooltip.push([
+                        `### ${doc.uri.fsPath}`,
+                        "```json",
+                        JSON.stringify(filteredData, undefined, "\t"),
+                        "```",
+                        "\n"
+                    ].join("\n"));
+                }
+                let tooltipContent;
+                if (docsDataInTooltip.length === 0) {
+                    tooltipContent = "No modified documents";
+                } else if (docsDataInTooltip.length <= 3) {
+                    tooltipContent = docsDataInTooltip.join("\n\n");
+                } else {
+                    const lastThree = docsDataInTooltip.slice(-3);
+                    tooltipContent = "...\n\n" + lastThree.join("\n\n");
+                }
+                const agenda = this._createEditSourceAgenda(editSources);
+                const tooltipWithCommand = ( new MarkdownString(
+                    tooltipContent + "\n\n[View Details](command:" + this._showStateInMarkdownDoc + ")"
+                ));
+                tooltipWithCommand.appendMarkdown(
+                    "\n\n" + agenda + "\n\nToggle decorations: [Click here](command:" + this._toggleDecorations + ")"
+                );
+                tooltipWithCommand.isTrusted = {
+                    enabledCommands: [this._toggleDecorations]
+                };
+                tooltipWithCommand.supportHtml = true;
+                return tooltipWithCommand;
+            });
+            reader.store.add(autorun(reader => {
+                statusBarItem.update({
+                    name: "editTelemetry",
+                    text: `$(edit) ${sumChangedCharacters.read(reader)} chars inserted`,
+                    ariaLabel: `Edit Source Tracking: ${sumChangedCharacters.read(reader)} modified characters`,
+                    tooltip: tooltipMarkdownString.read(reader),
+                    command: this._showStateInMarkdownDoc
+                });
+            }));
+            reader.store.add(CommandsRegistry.registerCommand(this._toggleDecorations, () => {
+                this._editSourceTrackingShowDecorations.set(!this._editSourceTrackingShowDecorations.read(undefined), undefined);
+            }));
+        }));
+    }
+    _createEditSourceAgenda(editSources) {
+        const editSourcesSeen = ( new Set());
+        const editSourceInfo = [];
+        for (const editSource of editSources) {
+            if (!( editSourcesSeen.has(( editSource.toString())))) {
+                editSourcesSeen.add(( editSource.toString()));
+                editSourceInfo.push({
+                    name: ( editSource.toString()),
+                    color: editSource.getColor()
+                });
+            }
+        }
+        const agendaItems = ( editSourceInfo.map(
+            info => `<span style="background-color:${info.color};border-radius:3px;">${info.name}</span>`
+        ));
+        return agendaItems.join(" ");
+    }
+};
+EditTrackingFeature = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, IInstantiationService)), ( __param(4, IStatusbarService)), ( __param(5, IEditorService)), ( __param(6, IExtensionService))], EditTrackingFeature));
+function makeSettable(obs) {
+    const overrideObs = observableValue("overrideObs", undefined);
+    return derivedWithSetter(overrideObs, reader => {
+        return overrideObs.read(reader) ?? obs.read(reader);
+    }, (value, tx) => {
+        overrideObs.set(value, tx);
+    });
+}
+
+export { EditTrackingFeature };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/telemetry/editSourceTrackingImpl.d.ts

@@ -0,0 +1,48 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IUserAttentionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userAttention/common/userAttentionService.service";
+import { AnnotatedDocument, IAnnotatedDocuments } from "../helpers/annotatedDocuments.js";
+import { DocumentEditSourceTracker, TrackedEdit } from "./editTracker.js";
+import { ScmAdapter } from "./scmAdapter.js";
+import { IRandomService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/randomService.service";
+type EditTelemetryMode = "longterm" | "10minFocusWindow" | "20minFocusWindow";
+type EditTelemetryTrigger = "10hours" | "hashChange" | "branchChange" | "closed" | "time";
+export declare class EditSourceTrackingImpl extends Disposable {
+    private readonly _statsEnabled;
+    private readonly _annotatedDocuments;
+    private readonly _instantiationService;
+    readonly docsState: IObservable<Map<import("../helpers/observableWorkspace.js").IObservableDocument, TrackedDocumentInfo>>;
+    private readonly _states;
+    constructor(_statsEnabled: IObservable<boolean>, _annotatedDocuments: IAnnotatedDocuments, _instantiationService: IInstantiationService);
+}
+declare class TrackedDocumentInfo extends Disposable {
+    private readonly _doc;
+    private readonly _scm;
+    private readonly _statsEnabled;
+    private readonly _instantiationService;
+    private readonly _telemetryService;
+    private readonly _randomService;
+    private readonly _userAttentionService;
+    readonly longtermTracker: IObservable<DocumentEditSourceTracker<undefined> | undefined>;
+    readonly windowedTracker: IObservable<DocumentEditSourceTracker<undefined> | undefined>;
+    readonly windowedFocusTracker: IObservable<DocumentEditSourceTracker<undefined> | undefined>;
+    private readonly _repo;
+    constructor(_doc: AnnotatedDocument, _scm: ScmAdapter, _statsEnabled: IObservable<boolean>, _instantiationService: IInstantiationService, _telemetryService: ITelemetryService, _randomService: IRandomService, _userAttentionService: IUserAttentionService);
+    sendTelemetry(mode: EditTelemetryMode, trigger: EditTelemetryTrigger, t: DocumentEditSourceTracker, focusTime: number, actualTime: number): Promise<void>;
+    getTelemetryData(ranges: readonly TrackedEdit[]): {
+        nesModifiedCount: number;
+        inlineCompletionsCopilotModifiedCount: number;
+        inlineCompletionsNESModifiedCount: number;
+        otherAIModifiedCount: number;
+        userModifiedCount: number;
+        ideModifiedCount: number;
+        unknownModifiedCount: number;
+        externalModifiedCount: number;
+        totalModifiedCharactersInFinalState: number;
+        languageId: string;
+        isTrackedByGit: Promise<boolean> | undefined;
+    };
+}
+export {};