@codingame/monaco-vscode-telemetry-service-override 32.0.2 → 34.0.0

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/editStats/aiStatsFeature.js

@@ -0,0 +1,213 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { sumBy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { TaskQueue, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable, toDisposable } 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 { isAiEdit, isUserEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { AiStatsStatusBar } from './aiStatsStatusBar.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+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';
+import { mapObservableArrayCached } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+let AiStatsFeature = class AiStatsFeature extends Disposable {
+    constructor(annotatedDocuments, _storageService, _instantiationService) {
+        super();
+        this._storageService = _storageService;
+        this._instantiationService = _instantiationService;
+        this._dataVersion = observableValue(this, 0);
+        this.aiRate = ( this._dataVersion.map(() => {
+            const val = this._data.getValue();
+            if (!val) {
+                return 0;
+            }
+            const r = average(val.sessions, session => {
+                const sum = session.typedCharacters + session.aiCharacters;
+                if (sum === 0) {
+                    return 0;
+                }
+                return session.aiCharacters / sum;
+            });
+            return r;
+        }));
+        this.sessionCount = derived(this, r => {
+            this._dataVersion.read(r);
+            const val = this._data.getValue();
+            if (!val) {
+                return 0;
+            }
+            return val.sessions.length;
+        });
+        this.sessions = derived(this, r => {
+            this._dataVersion.read(r);
+            const val = this._data.getValue();
+            if (!val) {
+                return [];
+            }
+            return val.sessions;
+        });
+        this.acceptedInlineSuggestionsToday = derived(this, r => {
+            this._dataVersion.read(r);
+            const val = this._data.getValue();
+            if (!val) {
+                return 0;
+            }
+            const startOfToday = ( new Date());
+            startOfToday.setHours(0, 0, 0, 0);
+            const sessionsToday = val.sessions.filter(s => s.startTime > startOfToday.getTime());
+            return sumBy(sessionsToday, s => s.acceptedInlineSuggestions ?? 0);
+        });
+        const storedValue = getStoredValue(
+            this._storageService,
+            "aiStats",
+            StorageScope.WORKSPACE,
+            StorageTarget.USER
+        );
+        this._data = rateLimitWrite(storedValue, 1 / 60, this._store);
+        this.aiRate.recomputeInitiallyAndOnChange(this._store);
+        this._register(autorun(reader => {
+            reader.store.add(
+                this._instantiationService.createInstance(AiStatsStatusBar.hot.read(reader), this)
+            );
+        }));
+        const lastRequestIds = [];
+        const obs = mapObservableArrayCached(this, annotatedDocuments.documents, (doc, store) => {
+            store.add(runOnChange(doc.documentWithAnnotations.value, (_val, _prev, edit) => {
+                const e = AnnotatedStringEdit.compose(( edit.map(e => e.edit)));
+                const curSession = ( new Lazy(() => this._getDataAndSession()));
+                for (const r of e.replacements) {
+                    if (isAiEdit(r.data.editSource)) {
+                        curSession.value.currentSession.aiCharacters += r.newText.length;
+                    } else if (isUserEdit(r.data.editSource)) {
+                        curSession.value.currentSession.typedCharacters += r.newText.length;
+                    }
+                }
+                if (e.replacements.length > 0) {
+                    const sessionToUpdate = curSession.value.currentSession;
+                    const s = e.replacements[0].data.editSource;
+                    if (s.metadata.source === "inlineCompletionAccept") {
+                        if (sessionToUpdate.acceptedInlineSuggestions === undefined) {
+                            sessionToUpdate.acceptedInlineSuggestions = 0;
+                        }
+                        sessionToUpdate.acceptedInlineSuggestions += 1;
+                    }
+                    if (s.metadata.source === "Chat.applyEdits" && s.metadata.$$requestId !== undefined) {
+                        const didSeeRequestId = lastRequestIds.includes(s.metadata.$$requestId);
+                        if (!didSeeRequestId) {
+                            lastRequestIds.push(s.metadata.$$requestId);
+                            if (lastRequestIds.length > 10) {
+                                lastRequestIds.shift();
+                            }
+                            if (sessionToUpdate.chatEditCount === undefined) {
+                                sessionToUpdate.chatEditCount = 0;
+                            }
+                            sessionToUpdate.chatEditCount += 1;
+                        }
+                    }
+                }
+                if (curSession.hasValue) {
+                    this._data.writeValue(curSession.value.data);
+                    this._dataVersion.set(this._dataVersion.get() + 1, undefined);
+                }
+            }));
+        });
+        obs.recomputeInitiallyAndOnChange(this._store);
+    }
+    _getDataAndSession() {
+        const state = this._data.getValue() ?? {
+            sessions: []
+        };
+        const sessionLengthMs = 5 * 60 * 1000;
+        let lastSession = state.sessions.at(-1);
+        const nowTime = Date.now();
+        if (!lastSession || nowTime - lastSession.startTime > sessionLengthMs) {
+            state.sessions.push({
+                startTime: nowTime,
+                typedCharacters: 0,
+                aiCharacters: 0,
+                acceptedInlineSuggestions: 0,
+                chatEditCount: 0
+            });
+            lastSession = state.sessions.at(-1);
+            const dayMs = 24 * 60 * 60 * 1000;
+            while (state.sessions.length > dayMs / sessionLengthMs) {
+                state.sessions.shift();
+            }
+        }
+        return {
+            data: state,
+            currentSession: lastSession
+        };
+    }
+};
+AiStatsFeature = ( __decorate([( __param(1, IStorageService)), ( __param(2, IInstantiationService))], AiStatsFeature));
+function average(arr, selector) {
+    if (arr.length === 0) {
+        return 0;
+    }
+    const s = sumBy(arr, selector);
+    return s / arr.length;
+}
+function rateLimitWrite(targetValue, maxWritesPerSecond, store) {
+    const queue = ( new TaskQueue());
+    let _value = undefined;
+    let valueVersion = 0;
+    let savedVersion = 0;
+    store.add(toDisposable(() => {
+        if (valueVersion !== savedVersion) {
+            targetValue.writeValue(_value);
+            savedVersion = valueVersion;
+        }
+    }));
+    return {
+        writeValue(value) {
+            valueVersion++;
+            const v = valueVersion;
+            _value = value;
+            queue.clearPending();
+            queue.schedule(async () => {
+                targetValue.writeValue(value);
+                savedVersion = v;
+                await timeout(5000);
+            });
+        },
+        getValue() {
+            if (valueVersion > 0) {
+                return _value;
+            }
+            return targetValue.getValue();
+        }
+    };
+}
+function getStoredValue(service, key, scope, target) {
+    let lastValue = undefined;
+    let hasLastValue = false;
+    return {
+        writeValue(value) {
+            if (value === undefined) {
+                service.remove(key, scope);
+            } else {
+                service.store(key, JSON.stringify(value), scope, target);
+            }
+            lastValue = value;
+        },
+        getValue() {
+            if (hasLastValue) {
+                return lastValue;
+            }
+            const strVal = service.get(key, scope);
+            lastValue = strVal === undefined ? undefined : JSON.parse(strVal);
+            hasLastValue = true;
+            return lastValue;
+        }
+    };
+}
+
+export { AiStatsFeature };

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

@@ -0,0 +1,27 @@
+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 { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IStatusbarService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/statusbar/browser/statusbar.service";
+import type { AiStatsFeature } from "./aiStatsFeature.js";
+import { ISessionData } from "./aiStatsChart.js";
+export declare class AiStatsStatusBar extends Disposable {
+    private readonly _aiStatsFeature;
+    private readonly _statusbarService;
+    private readonly _commandService;
+    private readonly _telemetryService;
+    static readonly hot: IObservable<typeof AiStatsStatusBar>;
+    constructor(_aiStatsFeature: AiStatsFeature, _statusbarService: IStatusbarService, _commandService: ICommandService, _telemetryService: ITelemetryService);
+    private _sendHoverTelemetry;
+    private _createStatusBar;
+}
+export interface IAiStatsHoverData {
+    readonly aiRate: IObservable<number>;
+    readonly acceptedInlineSuggestionsToday: IObservable<number>;
+    readonly sessions: IObservable<readonly ISessionData[]>;
+}
+export interface IAiStatsHoverOptions {
+    readonly data: IAiStatsHoverData;
+    readonly onOpenSettings?: () => void;
+}
+export declare function createAiStatsHover(options: IAiStatsHoverOptions): import("@codingame/monaco-vscode-api/vscode/vs/base/browser/dom").ObserverNode<HTMLDivElement>;

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/editStats/aiStatsStatusBar.js

@@ -0,0 +1,250 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { n } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { createHotClass } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hotReloadHelpers';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { nativeHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.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 { AI_STATS_SETTING_ID } from '../settingIds.js';
+import { createAiStatsChart } from './aiStatsChart.js';
+import * as media from './media.css';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+registerCss(media);
+let AiStatsStatusBar = class AiStatsStatusBar extends Disposable {
+    static {
+        this.hot = createHotClass(this);
+    }
+    constructor(_aiStatsFeature, _statusbarService, _commandService, _telemetryService) {
+        super();
+        this._aiStatsFeature = _aiStatsFeature;
+        this._statusbarService = _statusbarService;
+        this._commandService = _commandService;
+        this._telemetryService = _telemetryService;
+        this._register(autorun(reader => {
+            const statusBarItem = this._createStatusBar().keepUpdated(reader.store);
+            const store = this._register(( new DisposableStore()));
+            reader.store.add(this._statusbarService.addEntry({
+                name: ( localize(9597, "Inline Suggestions")),
+                ariaLabel: ( localize(9598, "Inline suggestions status bar")),
+                text: "",
+                tooltip: {
+                    element: async _token => {
+                        this._sendHoverTelemetry();
+                        store.clear();
+                        const elem = createAiStatsHover({
+                            data: this._aiStatsFeature,
+                            onOpenSettings: () => openSettingsCommand({
+                                ids: [AI_STATS_SETTING_ID]
+                            }).run(this._commandService)
+                        });
+                        return elem.keepUpdated(store).element;
+                    },
+                    markdownNotSupportedFallback: undefined
+                },
+                content: statusBarItem.element
+            }, "aiStatsStatusBar", StatusbarAlignment.RIGHT, 100));
+        }));
+    }
+    _sendHoverTelemetry() {
+        this._telemetryService.publicLog2("aiStatsStatusBar.hover", {
+            aiRate: this._aiStatsFeature.aiRate.get()
+        });
+    }
+    _createStatusBar() {
+        return n.div({
+            style: {
+                height: "100%",
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                marginLeft: "3px",
+                marginRight: "3px"
+            }
+        }, [n.div({
+            class: "ai-stats-status-bar",
+            style: {
+                display: "flex",
+                flexDirection: "column",
+                width: 50,
+                height: 6,
+                borderRadius: 6,
+                borderWidth: "1px",
+                borderStyle: "solid"
+            }
+        }, [n.div({
+            style: {
+                flex: 1,
+                display: "flex",
+                overflow: "hidden",
+                borderRadius: 6,
+                border: "1px solid transparent"
+            }
+        }, [n.div({
+            style: {
+                width: ( this._aiStatsFeature.aiRate.map(v => `${v * 100}%`)),
+                backgroundColor: "currentColor"
+            }
+        })])])]);
+    }
+};
+AiStatsStatusBar = ( __decorate([( __param(1, IStatusbarService)), ( __param(2, ICommandService)), ( __param(3, ITelemetryService))], AiStatsStatusBar));
+function createAiStatsHover(options) {
+    const chartViewMode = observableValue("chartViewMode", "days");
+    const aiRatePercent = ( options.data.aiRate.map(r => `${Math.round(r * 100)}%`));
+    const createToggleButton = (mode, tooltip, icon) => {
+        return derived(reader => {
+            const currentMode = chartViewMode.read(reader);
+            const isActive = currentMode === mode;
+            return n.div({
+                class: ["chart-toggle-button", isActive ? "active" : ""],
+                style: {
+                    padding: "2px 4px",
+                    borderRadius: "3px",
+                    cursor: "pointer",
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center"
+                },
+                onclick: () => {
+                    chartViewMode.set(mode, undefined);
+                },
+                title: tooltip
+            }, [n.div({
+                class: ThemeIcon.asClassName(icon),
+                style: {
+                    fontSize: "14px"
+                }
+            })]);
+        });
+    };
+    return n.div({
+        class: "ai-stats-status-bar"
+    }, [n.div({
+        class: "header",
+        style: {
+            minWidth: "280px"
+        }
+    }, [n.div({
+        style: {
+            flex: 1
+        }
+    }, [( localize(9599, "AI Usage Statistics"))]), n.div({
+        style: {
+            marginLeft: "auto"
+        }
+    }, options.onOpenSettings ? actionBar([{
+        action: {
+            id: "aiStats.statusBar.settings",
+            label: "",
+            enabled: true,
+            run: options.onOpenSettings,
+            class: ThemeIcon.asClassName(Codicon.gear),
+            tooltip: ( localize(9600, "Configure"))
+        },
+        options: {
+            icon: true,
+            label: false,
+            hoverDelegate: nativeHoverDelegate
+        }
+    }]) : [])]), n.div({
+        style: {
+            display: "flex"
+        }
+    }, [n.div({
+        style: {
+            flex: 1,
+            paddingRight: "4px"
+        }
+    }, [( localize(9601, "AI vs Typing Average: {0}", aiRatePercent.get()))])]), n.div({
+        style: {
+            flex: 1,
+            paddingRight: "4px"
+        }
+    }, [( localize(
+        9602,
+        "Accepted inline suggestions today: {0}",
+        options.data.acceptedInlineSuggestionsToday.get()
+    ))]),
+    n.div({
+        style: {
+            marginTop: "8px",
+            borderTop: "1px solid var(--vscode-widget-border)",
+            paddingTop: "8px"
+        }
+    }, [
+    n.div({
+        class: "header",
+        style: {
+            display: "flex",
+            alignItems: "center",
+            marginBottom: "4px"
+        }
+    }, [n.div({
+        style: {
+            flex: 1
+        }
+    }, [( chartViewMode.map(mode => mode === "days" ? ( localize(9603, "AI Rate by Day")) : ( localize(9604, "AI Rate by Session"))))]), n.div({
+        class: "chart-view-toggle",
+        style: {
+            marginLeft: "auto",
+            display: "flex",
+            gap: "2px"
+        }
+    }, [createToggleButton("days", ( localize(9605, "Days")), Codicon.calendar), createToggleButton("sessions", ( localize(9606, "Sessions")), Codicon.listFlat)])]),
+    derived(reader => {
+        const sessions = options.data.sessions.read(reader);
+        const viewMode = chartViewMode.read(reader);
+        return n.div({
+            ref: container => {
+                const chart = createAiStatsChart({
+                    sessions,
+                    viewMode
+                });
+                container.appendChild(chart);
+            }
+        });
+    })])]);
+}
+function actionBar(actions, options) {
+    return derived(_reader => n.div({
+        class: [],
+        style: {},
+        ref: elem => {
+            const actionBar = _reader.store.add(( new ActionBar(elem, options)));
+            for (const {
+                action,
+                options
+            } of actions) {
+                actionBar.push(action, options);
+            }
+        }
+    }));
+}
+class CommandWithArgs {
+    constructor(commandId, args = []) {
+        this.commandId = commandId;
+        this.args = args;
+    }
+    run(commandService) {
+        commandService.executeCommand(this.commandId, ...this.args);
+    }
+}
+function openSettingsCommand(options = {}) {
+    return ( new CommandWithArgs("workbench.action.openSettings", [{
+        query: options.ids ? ( options.ids.map(id => `@id:${id}`)).join(" ") : undefined
+    }]));
+}
+
+export { AiStatsStatusBar, createAiStatsHover };

package/vscode/src/vs/workbench/contrib/editTelemetry/browser/editStats/media.css

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* Overall */
+
+.ai-stats-status-bar {
+	margin-top: 4px;
+	margin-bottom: 4px;
+
+	hr {
+		margin-top: 8px;
+		margin-bottom: 8px;
+	}
+
+	div.header {
+		display: flex;
+		align-items: center;
+		color: var(--vscode-descriptionForeground);
+		margin-bottom: 4px;
+		font-size: 12px;
+		font-weight: 600;
+	}
+
+	div.description {
+		font-size: 11px;
+		color: var(--vscode-descriptionForeground);
+	}
+
+	.monaco-button {
+		margin-top: 5px;
+		margin-bottom: 5px;
+	}
+
+	/* Chart toggle buttons */
+	.chart-view-toggle {
+		display: flex;
+		gap: 2px;
+	}
+
+	.chart-toggle-button {
+		padding: 2px 6px;
+		border-radius: 3px;
+		cursor: pointer;
+		opacity: 0.6;
+		transition: opacity 0.15s, background-color 0.15s;
+	}
+
+	.chart-toggle-button:hover {
+		opacity: 1;
+		background-color: var(--vscode-toolbar-hoverBackground);
+	}
+
+	.chart-toggle-button.active {
+		opacity: 1;
+		background-color: var(--vscode-toolbar-activeBackground);
+	}
+
+	/* Chart container */
+	.ai-stats-chart-container {
+		margin-top: 4px;
+	}
+
+	.ai-stats-chart-container svg {
+		overflow: visible;
+	}
+
+	/* Setup for New User */
+
+	.setup .chat-feature-container {
+		display: flex;
+		align-items: center;
+		gap: 5px;
+		padding: 4px;
+	}
+
+	/* Settings */
+
+	.settings {
+		display: flex;
+		flex-direction: column;
+		gap: 5px;
+	}
+
+	.settings .setting {
+		display: flex;
+		align-items: center;
+	}
+
+	.settings .setting .monaco-checkbox {
+		height: 14px;
+		width: 14px;
+		margin-right: 5px;
+	}
+
+	.settings .setting .setting-label {
+		cursor: pointer;
+	}
+
+	.settings .setting.disabled .setting-label {
+		color: var(--vscode-disabledForeground);
+	}
+
+
+	/* Contributions */
+
+	.contribution .body {
+		display: flex;
+		flex-direction: row;
+		align-items: center;
+		gap: 5px;
+
+		.description,
+		.detail-item {
+			display: flex;
+			align-items: center;
+			gap: 3px;
+		}
+
+		.detail-item,
+		.detail-item a {
+			margin-left: auto;
+			color: var(--vscode-descriptionForeground);
+		}
+	}
+}

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

@@ -0,0 +1 @@
+export {};