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

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/editTelemetry.contribution.js

@@ -0,0 +1,75 @@
+
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { EditTelemetryContribution } from './editTelemetryContribution.js';
+import { AI_STATS_SETTING_ID, EDIT_TELEMETRY_SETTING_ID } from './settingIds.js';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { EDIT_TELEMETRY_SHOW_DECORATIONS, EDIT_TELEMETRY_SHOW_STATUS_BAR, EDIT_TELEMETRY_DETAILS_SETTING_ID } from './settings.js';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/editTelemetry/browser/telemetry/aiEditTelemetry/aiEditTelemetryServiceImpl';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+
+registerWorkbenchContribution2(
+    "EditTelemetryContribution",
+    EditTelemetryContribution,
+    WorkbenchPhase.AfterRestored
+);
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "task",
+    order: 100,
+    title: ( localize(9445, "Edit Telemetry")),
+    type: "object",
+    properties: {
+        [EDIT_TELEMETRY_SETTING_ID]: {
+            markdownDescription: ( localize(
+                9446,
+                "Controls whether to enable telemetry for edit statistics (only sends statistics if general telemetry is enabled)."
+            )),
+            type: "boolean",
+            default: true,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [AI_STATS_SETTING_ID]: {
+            markdownDescription: ( localize(
+                9447,
+                "Controls whether to enable AI statistics in the editor. The gauge shows the average AI rate across 5-minute sessions, where each session's rate is calculated as AI-inserted characters divided by total inserted characters."
+            )),
+            type: "boolean",
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [EDIT_TELEMETRY_DETAILS_SETTING_ID]: {
+            markdownDescription: ( localize(
+                9448,
+                "Controls whether to enable telemetry for detailed edit statistics (only sends statistics if general telemetry is enabled)."
+            )),
+            type: "boolean",
+            default: false,
+            tags: ["experimental"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        [EDIT_TELEMETRY_SHOW_STATUS_BAR]: {
+            markdownDescription: ( localize(9449, "Controls whether to show the status bar for edit telemetry.")),
+            type: "boolean",
+            default: false,
+            tags: ["experimental"]
+        },
+        [EDIT_TELEMETRY_SHOW_DECORATIONS]: {
+            markdownDescription: ( localize(9450, "Controls whether to show decorations for edit telemetry.")),
+            type: "boolean",
+            default: false,
+            tags: ["experimental"]
+        }
+    }
+});

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

@@ -0,0 +1,8 @@
+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 { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+export declare class EditTelemetryContribution extends Disposable {
+    constructor(instantiationService: IInstantiationService, configurationService: IConfigurationService, telemetryService: ITelemetryService, chatEntitlementService: IChatEntitlementService);
+}

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/editTelemetryContribution.js

@@ -0,0 +1,82 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { telemetryLevelEnabled, TelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { AnnotatedDocuments } from './helpers/annotatedDocuments.js';
+import { EditTrackingFeature } from './telemetry/editSourceTrackingFeature.js';
+import { VSCodeWorkspace } from './helpers/vscodeObservableWorkspace.js';
+import { AiStatsFeature } from './editStats/aiStatsFeature.js';
+import { EDIT_TELEMETRY_SETTING_ID, AI_STATS_SETTING_ID } from './settingIds.js';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { AiContributionFeature } from './aiContributionFeature.js';
+import { derived } 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';
+
+let EditTelemetryContribution = class EditTelemetryContribution extends Disposable {
+    constructor(
+        instantiationService,
+        configurationService,
+        telemetryService,
+        chatEntitlementService
+    ) {
+        super();
+        const workspace = derived(
+            reader => reader.store.add(instantiationService.createInstance(VSCodeWorkspace))
+        );
+        const annotatedDocuments = derived(reader => reader.store.add(
+            instantiationService.createInstance(AnnotatedDocuments, workspace.read(reader))
+        ));
+        const editSourceTrackingEnabled = observableConfigValue(EDIT_TELEMETRY_SETTING_ID, true, configurationService);
+        this._register(autorun(r => {
+            const enabled = editSourceTrackingEnabled.read(r);
+            if (!enabled || !telemetryLevelEnabled(telemetryService, TelemetryLevel.USAGE)) {
+                return;
+            }
+            r.store.add(
+                instantiationService.createInstance(EditTrackingFeature, workspace.read(r), annotatedDocuments.read(r))
+            );
+        }));
+        const aiStatsEnabled = observableConfigValue(AI_STATS_SETTING_ID, true, configurationService);
+        this._register(autorun(r => {
+            const enabled = aiStatsEnabled.read(r);
+            const aiDisabled = chatEntitlementService.sentimentObs.read(r).hidden;
+            if (!enabled || aiDisabled) {
+                return;
+            }
+            r.store.add(
+                instantiationService.createInstance(AiStatsFeature, annotatedDocuments.read(r))
+            );
+        }));
+        this._register(
+            CommandsRegistry.registerCommand("_aiEdits.hasAiContributions", () => false)
+        );
+        this._register(
+            CommandsRegistry.registerCommand("_aiEdits.clearAiContributions", () => {})
+        );
+        this._register(
+            CommandsRegistry.registerCommand("_aiEdits.clearAllAiContributions", () => {})
+        );
+        const addAICoAuthor = observableConfigValue("git.addAICoAuthor", "off", configurationService);
+        this._register(autorun(r => {
+            if (addAICoAuthor.read(r) === "off") {
+                return;
+            }
+            const aiDisabled = chatEntitlementService.sentimentObs.read(r).hidden;
+            if (aiDisabled) {
+                return;
+            }
+            r.store.add(
+                instantiationService.createInstance(AiContributionFeature, annotatedDocuments.read(r))
+            );
+        }));
+    }
+};
+EditTelemetryContribution = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IConfigurationService)), ( __param(2, ITelemetryService)), ( __param(3, IChatEntitlementService))], EditTelemetryContribution));
+
+export { EditTelemetryContribution };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/helpers/annotatedDocuments.d.ts

@@ -0,0 +1,30 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IDocumentWithAnnotatedEdits, EditSourceData } from "./documentWithAnnotatedEdits.js";
+import { ObservableWorkspace, IObservableDocument } from "./observableWorkspace.js";
+export interface IAnnotatedDocuments {
+    readonly documents: IObservable<readonly AnnotatedDocument[]>;
+}
+export declare class AnnotatedDocuments extends Disposable implements IAnnotatedDocuments {
+    private readonly _workspace;
+    private readonly _instantiationService;
+    readonly documents: IObservable<readonly AnnotatedDocument[]>;
+    private readonly _states;
+    constructor(_workspace: ObservableWorkspace, _instantiationService: IInstantiationService);
+}
+export declare class UriVisibilityProvider {
+    private readonly _editorGroupsService;
+    private readonly visibleUris;
+    constructor(_editorGroupsService: IEditorGroupsService);
+    isVisible(uri: URI, reader: IReader): boolean;
+}
+export declare class AnnotatedDocument extends Disposable {
+    readonly document: IObservableDocument;
+    readonly isVisible: IObservable<boolean>;
+    private readonly _instantiationService;
+    readonly documentWithAnnotations: IDocumentWithAnnotatedEdits<EditSourceData>;
+    constructor(document: IObservableDocument, isVisible: IObservable<boolean>, _instantiationService: IInstantiationService);
+}

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/helpers/annotatedDocuments.js

@@ -0,0 +1,79 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { EditorResourceAccessor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { DocumentWithSourceAnnotatedEdits, CombineStreamedChanges, MinimizeEditsProcessor } from './documentWithAnnotatedEdits.js';
+import { mapObservableArrayCached, derivedObservableWithCache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+
+let AnnotatedDocuments = class AnnotatedDocuments extends Disposable {
+    constructor(_workspace, _instantiationService) {
+        super();
+        this._workspace = _workspace;
+        this._instantiationService = _instantiationService;
+        const uriVisibilityProvider = this._instantiationService.createInstance(UriVisibilityProvider);
+        this._states = mapObservableArrayCached(this, this._workspace.documents, (doc, store) => {
+            const docIsVisible = derived(reader => uriVisibilityProvider.isVisible(doc.uri, reader));
+            const wasEverVisible = derivedObservableWithCache(this, (reader, lastVal) => lastVal || docIsVisible.read(reader));
+            return ( wasEverVisible.map(v => v ? store.add(
+                this._instantiationService.createInstance(AnnotatedDocument, doc, docIsVisible)
+            ) : undefined));
+        });
+        this.documents = ( this._states.map((vals, reader) => ( vals.map(v => v.read(reader))).filter(isDefined)));
+        this.documents.recomputeInitiallyAndOnChange(this._store);
+    }
+};
+AnnotatedDocuments = ( __decorate([( __param(1, IInstantiationService))], AnnotatedDocuments));
+let UriVisibilityProvider = class UriVisibilityProvider {
+    constructor(_editorGroupsService) {
+        this._editorGroupsService = _editorGroupsService;
+        const onDidAddGroupSignal = observableSignalFromEvent(this, this._editorGroupsService.onDidAddGroup);
+        const onDidRemoveGroupSignal = observableSignalFromEvent(this, this._editorGroupsService.onDidRemoveGroup);
+        const groups = derived(this, reader => {
+            onDidAddGroupSignal.read(reader);
+            onDidRemoveGroupSignal.read(reader);
+            return this._editorGroupsService.groups;
+        });
+        this.visibleUris = ( mapObservableArrayCached(this, groups, g => {
+            const editors = observableFromEvent(this, g.onDidModelChange, () => g.editors);
+            return ( editors.map(e => ( e.map(editor => EditorResourceAccessor.getCanonicalUri(editor)))));
+        }).map((editors, reader) => {
+            const map = ( new Map());
+            for (const urisObs of editors) {
+                for (const uri of urisObs.read(reader)) {
+                    if (isDefined(uri)) {
+                        map.set(( uri.toString()), uri);
+                    }
+                }
+            }
+            return map;
+        }));
+    }
+    isVisible(uri, reader) {
+        return ( this.visibleUris.read(reader).has(( uri.toString())));
+    }
+};
+UriVisibilityProvider = ( __decorate([( __param(0, IEditorGroupsService))], UriVisibilityProvider));
+let AnnotatedDocument = class AnnotatedDocument extends Disposable {
+    constructor(document, isVisible, _instantiationService) {
+        super();
+        this.document = document;
+        this.isVisible = isVisible;
+        this._instantiationService = _instantiationService;
+        let processedDoc = this._store.add(( new DocumentWithSourceAnnotatedEdits(document)));
+        processedDoc = this._store.add(
+            this._instantiationService.createInstance(CombineStreamedChanges, processedDoc)
+        );
+        processedDoc = this._store.add(( new MinimizeEditsProcessor(processedDoc)));
+        this.documentWithAnnotations = processedDoc;
+    }
+};
+AnnotatedDocument = ( __decorate([( __param(2, IInstantiationService))], AnnotatedDocument));
+
+export { AnnotatedDocument, AnnotatedDocuments, UriVisibilityProvider };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/helpers/documentWithAnnotatedEdits.d.ts

@@ -0,0 +1,128 @@
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservableWithChange } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { AnnotatedStringEdit, IEditData, StringEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit";
+import { StringText } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/abstractText";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { TextModelEditSource } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IObservableDocument } from "./observableWorkspace.js";
+export interface IDocumentWithAnnotatedEdits<TEditData extends IEditData<TEditData> = EditKeySourceData> {
+    readonly value: IObservableWithChange<StringText, {
+        edit: AnnotatedStringEdit<TEditData>;
+    }>;
+    waitForQueue(): Promise<void>;
+}
+/**
+ * Creates a document that is a delayed copy of the original document,
+ * but with edits annotated with the source of the edit.
+*/
+export declare class DocumentWithSourceAnnotatedEdits extends Disposable implements IDocumentWithAnnotatedEdits<EditSourceData> {
+    private readonly _originalDoc;
+    readonly value: IObservableWithChange<StringText, {
+        edit: AnnotatedStringEdit<EditSourceData>;
+    }>;
+    constructor(_originalDoc: IObservableDocument);
+    waitForQueue(): Promise<void>;
+}
+/**
+ * Only joins touching edits if the source and the metadata is the same (e.g. requestUuids must be equal).
+*/
+export declare class EditSourceData implements IEditData<EditSourceData> {
+    readonly editSource: TextModelEditSource;
+    readonly source: EditSource;
+    readonly key: string;
+    constructor(editSource: TextModelEditSource);
+    join(data: EditSourceData): EditSourceData | undefined;
+    toEditSourceData(): EditKeySourceData;
+}
+export declare class EditKeySourceData implements IEditData<EditKeySourceData> {
+    readonly key: string;
+    readonly source: EditSource;
+    readonly representative: TextModelEditSource;
+    constructor(key: string, source: EditSource, representative: TextModelEditSource);
+    join(data: EditKeySourceData): EditKeySourceData | undefined;
+}
+export declare abstract class EditSourceBase {
+    private static _cache;
+    static create(reason: TextModelEditSource): EditSource;
+    abstract getColor(): string;
+}
+export type EditSource = InlineSuggestEditSource | ChatEditSource | IdeEditSource | UserEditSource | UnknownEditSource | ExternalEditSource;
+export declare class InlineSuggestEditSource extends EditSourceBase {
+    readonly kind: "completion" | "nes";
+    readonly extensionId: string;
+    readonly providerId: string;
+    readonly type: "word" | "line" | undefined;
+    readonly category = "ai";
+    readonly feature = "inlineSuggest";
+    constructor(kind: "completion" | "nes", extensionId: string, providerId: string, type: "word" | "line" | undefined);
+    toString(): string;
+    getColor(): string;
+}
+declare class ChatEditSource extends EditSourceBase {
+    readonly kind: "sidebar" | "inline";
+    readonly category = "ai";
+    readonly feature = "chat";
+    constructor(kind: "sidebar" | "inline");
+    toString(): string;
+    getColor(): string;
+}
+declare class IdeEditSource extends EditSourceBase {
+    readonly feature: "suggest" | "format" | string;
+    readonly category = "ide";
+    constructor(feature: "suggest" | "format" | string);
+    toString(): string;
+    getColor(): string;
+}
+declare class UserEditSource extends EditSourceBase {
+    readonly category = "user";
+    constructor();
+    toString(): string;
+    getColor(): string;
+}
+/** Caused by external tools that trigger a reload from disk */
+declare class ExternalEditSource extends EditSourceBase {
+    readonly category = "external";
+    constructor();
+    toString(): string;
+    getColor(): string;
+}
+declare class UnknownEditSource extends EditSourceBase {
+    readonly category = "unknown";
+    constructor();
+    toString(): string;
+    getColor(): string;
+}
+export declare class CombineStreamedChanges<TEditData extends (EditKeySourceData | EditSourceData) & IEditData<TEditData>> extends Disposable implements IDocumentWithAnnotatedEdits<TEditData> {
+    private readonly _originalDoc;
+    private readonly _instantiationService;
+    private readonly _value;
+    readonly value: IObservableWithChange<StringText, {
+        edit: AnnotatedStringEdit<TEditData>;
+    }>;
+    private readonly _runStore;
+    private _runQueue;
+    private readonly _diffService;
+    constructor(_originalDoc: IDocumentWithAnnotatedEdits<TEditData>, _instantiationService: IInstantiationService);
+    _restart(): Promise<void>;
+    private _run;
+    waitForQueue(): Promise<void>;
+}
+export declare class DiffService {
+    private readonly _editorWorkerService;
+    constructor(_editorWorkerService: IEditorWorkerService);
+    computeDiff(original: string, modified: string): Promise<StringEdit>;
+}
+export declare class MinimizeEditsProcessor<TEditData extends IEditData<TEditData>> extends Disposable implements IDocumentWithAnnotatedEdits<TEditData> {
+    private readonly _originalDoc;
+    readonly value: IObservableWithChange<StringText, {
+        edit: AnnotatedStringEdit<TEditData>;
+    }>;
+    constructor(_originalDoc: IDocumentWithAnnotatedEdits<TEditData>);
+    waitForQueue(): Promise<void>;
+}
+/**
+ * Removing the metadata allows touching edits from the same source to merged, even if they were caused by different actions (e.g. two user edits).
+ */
+export declare function createDocWithJustReason(docWithAnnotatedEdits: IDocumentWithAnnotatedEdits<EditSourceData>, store: DisposableStore): IDocumentWithAnnotatedEdits<EditKeySourceData>;
+export {};