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

package/index.js

@@ -6,6 +6,8 @@ import { TelemetryService } from './vscode/src/vs/workbench/services/telemetry/b
 import { IDataChannelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service';
 import { DataChannelService } from './vscode/src/vs/workbench/services/dataChannel/browser/dataChannelService.js';
 import './vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.js';
+import './vscode/src/vs/workbench/contrib/editTelemetry/browser/editTelemetry.contribution.js';
+import './vscode/src/vs/workbench/contrib/bracketPairColorizer2Telemetry/browser/bracketPairColorizer2Telemetry.contribution.js';
 
 function getServiceOverride() {
     return {

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@codingame/monaco-vscode-telemetry-service-override",
-  "version": "32.0.1",
+  "version": "33.0.9",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - telemetry service-override",
   "keywords": [],
+  "license": "MIT",
   "author": {
     "name": "CodinGame",
     "url": "http://www.codingame.com"
   },
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "32.0.1",
+    "@codingame/monaco-vscode-api": "33.0.9",
     "@microsoft/1ds-core-js": "3.2.18",
     "@microsoft/1ds-post-js": "3.2.18"
   },

package/vscode/src/vs/platform/telemetry/common/telemetryLogAppender.js

@@ -19,7 +19,7 @@ let TelemetryLogAppender = class TelemetryLogAppender extends Disposable {
             const justLoggingAndNotSending = isLoggingOnly(productService, environmentService);
             const logSuffix = justLoggingAndNotSending ? " (Not Sent)" : "";
             this.logger = this._register(loggerService.createLogger(id, {
-                name: ( localize(2123, "Telemetry{0}", logSuffix)),
+                name: ( localize(2145, "Telemetry{0}", logSuffix)),
                 group: TelemetryLogGroup,
                 hidden: true
             }));

package/vscode/src/vs/platform/telemetry/common/telemetryService.js

@@ -164,28 +164,28 @@ let TelemetryService = class TelemetryService {
 TelemetryService = TelemetryService_1 = ( __decorate([( __param(1, IConfigurationService)), ( __param(2, IProductService))], TelemetryService));
 function getTelemetryLevelSettingDescription() {
     const telemetryText = ( localize(
-        2124,
+        2146,
         "Controls {0} telemetry, first-party extension telemetry, and participating third-party extension telemetry. Some third party extensions might not respect this setting. Consult the specific extension's documentation to be sure. Telemetry helps us better understand how {0} is performing, where improvements need to be made, and how features are being used.",
         product.nameLong
     ));
     const externalLinksStatement = !product.privacyStatementUrl ? ( localize(
-        2125,
+        2147,
         "Read more about the [data we collect]({0}).",
         "https://aka.ms/vscode-telemetry"
     )) : ( localize(
-        2126,
+        2148,
         "Read more about the [data we collect]({0}) and our [privacy statement]({1}).",
         "https://aka.ms/vscode-telemetry",
         product.privacyStatementUrl
     ));
     const restartString = !isWeb ? ( localize(
-        2127,
+        2149,
         "A full restart of the application is necessary for crash reporting changes to take effect."
     )) : "";
-    const crashReportsHeader = ( localize(2128, "Crash Reports"));
-    const errorsHeader = ( localize(2129, "Error Telemetry"));
-    const usageHeader = ( localize(2130, "Usage Data"));
-    const telemetryTableDescription = ( localize(2131, "The following table outlines the data sent with each setting:"));
+    const crashReportsHeader = ( localize(2150, "Crash Reports"));
+    const errorsHeader = ( localize(2151, "Error Telemetry"));
+    const usageHeader = ( localize(2152, "Usage Data"));
+    const telemetryTableDescription = ( localize(2153, "The following table outlines the data sent with each setting:"));
     const telemetryTable = `
 |       | ${crashReportsHeader} | ${errorsHeader} | ${usageHeader} |
 |:------|:-------------:|:---------------:|:----------:|
@@ -195,7 +195,7 @@ function getTelemetryLevelSettingDescription() {
 | off   |       -       |        -        |     -      |
 `;
     const deprecatedSettingNote = ( localize(
-        2132,
+        2154,
         "****Note:*** If this setting is 'off', no telemetry will be sent regardless of other telemetry settings. If this setting is set to anything except 'off' and telemetry is disabled with deprecated settings, no telemetry will be sent.*"
     ));
     const telemetryDescription = `
@@ -217,7 +217,7 @@ configurationRegistry.registerConfiguration({
     "id": TELEMETRY_SECTION_ID,
     "order": 1,
     "type": "object",
-    "title": ( localize(2133, "Telemetry")),
+    "title": ( localize(2155, "Telemetry")),
     "properties": {
         [TELEMETRY_SETTING_ID]: {
             "type": "string",
@@ -227,7 +227,7 @@ configurationRegistry.registerConfiguration({
                 TelemetryConfiguration.CRASH,
                 TelemetryConfiguration.OFF
             ],
-            "enumDescriptions": [( localize(2134, "Sends usage data, errors, and crash reports.")), ( localize(2135, "Sends general error telemetry and crash reports.")), ( localize(2136, "Sends OS level crash reports.")), ( localize(2137, "Disables all product telemetry."))],
+            "enumDescriptions": [( localize(2156, "Sends usage data, errors, and crash reports.")), ( localize(2157, "Sends general error telemetry and crash reports.")), ( localize(2158, "Sends OS level crash reports.")), ( localize(2159, "Disables all product telemetry."))],
             "markdownDescription": getTelemetryLevelSettingDescription(),
             "default": TelemetryConfiguration.ON,
             "restricted": true,
@@ -240,20 +240,20 @@ configurationRegistry.registerConfiguration({
                 localization: {
                     description: {
                         key: "telemetry.telemetryLevel.policyDescription",
-                        value: ( localize(2138, "Controls the level of telemetry."))
+                        value: ( localize(2160, "Controls the level of telemetry."))
                     },
                     enumDescriptions: [{
                         key: "telemetry.telemetryLevel.default",
-                        value: ( localize(2134, "Sends usage data, errors, and crash reports."))
+                        value: ( localize(2156, "Sends usage data, errors, and crash reports."))
                     }, {
                         key: "telemetry.telemetryLevel.error",
-                        value: ( localize(2135, "Sends general error telemetry and crash reports."))
+                        value: ( localize(2157, "Sends general error telemetry and crash reports."))
                     }, {
                         key: "telemetry.telemetryLevel.crash",
-                        value: ( localize(2136, "Sends OS level crash reports."))
+                        value: ( localize(2158, "Sends OS level crash reports."))
                     }, {
                         key: "telemetry.telemetryLevel.off",
-                        value: ( localize(2137, "Disables all product telemetry."))
+                        value: ( localize(2159, "Disables all product telemetry."))
                     }]
                 }
             }
@@ -262,7 +262,7 @@ configurationRegistry.registerConfiguration({
             type: "boolean",
             default: true,
             description: ( localize(
-                2139,
+                2161,
                 "Enable feedback mechanisms such as the issue reporter, surveys, and other feedback options."
             )),
             policy: {
@@ -273,7 +273,7 @@ configurationRegistry.registerConfiguration({
                     description: {
                         key: "telemetry.feedback.enabled",
                         value: ( localize(
-                            2139,
+                            2161,
                             "Enable feedback mechanisms such as the issue reporter, surveys, and other feedback options."
                         ))
                     }
@@ -283,11 +283,11 @@ configurationRegistry.registerConfiguration({
         [TELEMETRY_OLD_SETTING_ID]: {
             "type": "boolean",
             "markdownDescription": !product.privacyStatementUrl ? ( localize(
-                2140,
+                2162,
                 "Enable diagnostic data to be collected. This helps us to better understand how {0} is performing and where improvements need to be made.",
                 product.nameLong
             )) : ( localize(
-                2141,
+                2163,
                 "Enable diagnostic data to be collected. This helps us to better understand how {0} is performing and where improvements need to be made. [Read more]({1}) about what we collect and our privacy statement.",
                 product.nameLong,
                 product.privacyStatementUrl
@@ -295,7 +295,7 @@ configurationRegistry.registerConfiguration({
             "default": true,
             "restricted": true,
             "markdownDeprecationMessage": ( localize(
-                2142,
+                2164,
                 "If this setting is false, no telemetry will be sent regardless of the new setting's value. Deprecated in favor of the {0} setting.",
                 `\`#${TELEMETRY_SETTING_ID}#\``
             )),

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

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

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

@@ -0,0 +1,34 @@
+
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { EnablementState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+
+let BracketPairColorizer2TelemetryContribution = class BracketPairColorizer2TelemetryContribution {
+    constructor(configurationService, extensionsWorkbenchService, telemetryService) {
+        this.configurationService = configurationService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.telemetryService = telemetryService;
+        this.init().catch(onUnexpectedError);
+    }
+    async init() {
+        const bracketPairColorizerId = "coenraads.bracket-pair-colorizer-2";
+        await this.extensionsWorkbenchService.queryLocal();
+        const extension = this.extensionsWorkbenchService.installed.find(e => e.identifier.id === bracketPairColorizerId);
+        if (!extension || ((extension.enablementState !== EnablementState.EnabledGlobally) && (extension.enablementState !== EnablementState.EnabledWorkspace))) {
+            return;
+        }
+        const nativeBracketPairColorizationEnabledKey = "editor.bracketPairColorization.enabled";
+        const nativeColorizationEnabled = !!this.configurationService.getValue(nativeBracketPairColorizationEnabledKey);
+        this.telemetryService.publicLog2("bracketPairColorizerTwoUsage", {
+            nativeColorizationEnabled
+        });
+    }
+};
+BracketPairColorizer2TelemetryContribution = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IExtensionsWorkbenchService)), ( __param(2, ITelemetryService))], BracketPairColorizer2TelemetryContribution));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BracketPairColorizer2TelemetryContribution, LifecyclePhase.Restored);

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

@@ -0,0 +1,15 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAnnotatedDocuments } from "./helpers/annotatedDocuments.js";
+export type AiContributionLevel = "chatAndAgent" | "all";
+/**
+ * Tracks AI-generated edits across open documents using the edit telemetry pipeline.
+ */
+export declare class AiContributionFeature extends Disposable {
+    private readonly _trackers;
+    private readonly _documentsByUri;
+    constructor(annotatedDocuments: IAnnotatedDocuments);
+    dispose(): void;
+    private _createTrackerEntry;
+    private _hasAiContributions;
+    private _clearAiContributions;
+}

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

@@ -0,0 +1,97 @@
+
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { createDocWithJustReason } from './helpers/documentWithAnnotatedEdits.js';
+import { DocumentEditSourceTracker } from './telemetry/editTracker.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+class AiContributionFeature extends Disposable {
+    constructor(annotatedDocuments) {
+        super();
+        this._trackers = ( new ResourceMap());
+        this._documentsByUri = ( new ResourceMap());
+        this._register(autorun(reader => {
+            const docs = annotatedDocuments.documents.read(reader);
+            const activeUris = ( new ResourceMap());
+            for (const doc of docs) {
+                const uri = doc.document.uri;
+                activeUris.set(uri, true);
+                this._documentsByUri.set(uri, doc);
+                if (!( this._trackers.has(uri))) {
+                    this._trackers.set(uri, this._createTrackerEntry(doc));
+                }
+            }
+            for (const [uri, entry] of this._trackers) {
+                if (!( activeUris.has(uri))) {
+                    entry.trackerStore.dispose();
+                    this._trackers.delete(uri);
+                    this._documentsByUri.delete(uri);
+                }
+            }
+        }));
+        this._register(
+            CommandsRegistry.registerCommand("_aiEdits.hasAiContributions", (_accessor, resources, level) => {
+                return this._hasAiContributions(resources, level);
+            })
+        );
+        this._register(
+            CommandsRegistry.registerCommand("_aiEdits.clearAiContributions", (_accessor, resources) => {
+                this._clearAiContributions(resources);
+            })
+        );
+        this._register(
+            CommandsRegistry.registerCommand("_aiEdits.clearAllAiContributions", () => {
+                this._clearAiContributions();
+            })
+        );
+    }
+    dispose() {
+        for (const [, entry] of this._trackers) {
+            entry.trackerStore.dispose();
+        }
+        super.dispose();
+    }
+    _createTrackerEntry(doc) {
+        const trackerStore = ( new DisposableStore());
+        const docWithJustReason = createDocWithJustReason(doc.documentWithAnnotations, trackerStore);
+        const tracker = trackerStore.add(( new DocumentEditSourceTracker(docWithJustReason, undefined)));
+        return {
+            trackerStore,
+            tracker
+        };
+    }
+    _hasAiContributions(resources, level) {
+        for (const resource of resources) {
+            const entry = this._trackers.get(URI.revive(resource));
+            if (entry) {
+                for (const edit of entry.tracker.getTrackedRanges()) {
+                    if (edit.source.category === "ai" && (level === "all" || edit.source.feature === "chat")) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    _clearAiContributions(resources) {
+        const uris = resources ? ( resources.map(r => URI.revive(r))) : [...( this._trackers.keys())];
+        for (const uri of uris) {
+            const entry = this._trackers.get(uri);
+            if (entry) {
+                entry.trackerStore.dispose();
+                const doc = this._documentsByUri.get(uri);
+                if (doc) {
+                    this._trackers.set(uri, this._createTrackerEntry(doc));
+                } else {
+                    this._trackers.delete(uri);
+                    this._documentsByUri.delete(uri);
+                }
+            }
+        }
+    }
+}
+
+export { AiContributionFeature };

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

@@ -0,0 +1,24 @@
+export interface ISessionData {
+    startTime: number;
+    typedCharacters: number;
+    aiCharacters: number;
+    acceptedInlineSuggestions: number | undefined;
+    chatEditCount: number | undefined;
+}
+export interface IDailyAggregate {
+    date: string;
+    displayDate: string;
+    aiRate: number;
+    totalAiChars: number;
+    totalTypedChars: number;
+    inlineSuggestions: number;
+    chatEdits: number;
+    sessionCount: number;
+}
+export type ChartViewMode = "days" | "sessions";
+export declare function aggregateSessionsByDay(sessions: readonly ISessionData[]): IDailyAggregate[];
+export interface IAiStatsChartOptions {
+    sessions: readonly ISessionData[];
+    viewMode: ChartViewMode;
+}
+export declare function createAiStatsChart(options: IAiStatsChartOptions): HTMLElement;

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

@@ -0,0 +1,236 @@
+
+import { $, createElementNS } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import { chartsForeground, chartsLines, chartsBlue } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+
+function aggregateSessionsByDay(sessions) {
+    const dayMap = ( new Map());
+    for (const session of sessions) {
+        const date = ( new Date(session.startTime));
+        const isoDate = date.toISOString().split("T")[0];
+        const displayDate = date.toLocaleDateString(undefined, {
+            month: "short",
+            day: "numeric"
+        });
+        let aggregate = dayMap.get(isoDate);
+        if (!aggregate) {
+            aggregate = {
+                date: isoDate,
+                displayDate,
+                aiRate: 0,
+                totalAiChars: 0,
+                totalTypedChars: 0,
+                inlineSuggestions: 0,
+                chatEdits: 0,
+                sessionCount: 0
+            };
+            dayMap.set(isoDate, aggregate);
+        }
+        aggregate.totalAiChars += session.aiCharacters;
+        aggregate.totalTypedChars += session.typedCharacters;
+        aggregate.inlineSuggestions += session.acceptedInlineSuggestions ?? 0;
+        aggregate.chatEdits += session.chatEditCount ?? 0;
+        aggregate.sessionCount += 1;
+    }
+    for (const aggregate of ( dayMap.values())) {
+        const total = aggregate.totalAiChars + aggregate.totalTypedChars;
+        aggregate.aiRate = total > 0 ? aggregate.totalAiChars / total : 0;
+    }
+    return Array.from(( dayMap.values())).sort((a, b) => a.date.localeCompare(b.date));
+}
+function createAiStatsChart(options) {
+    const {
+        sessions: sessionsData,
+        viewMode: mode
+    } = options;
+    const width = 280;
+    const height = 100;
+    const margin = {
+        top: 10,
+        right: 10,
+        bottom: 25,
+        left: 30
+    };
+    const innerWidth = width - margin.left - margin.right;
+    const innerHeight = height - margin.top - margin.bottom;
+    const container = $(".ai-stats-chart-container");
+    container.style.position = "relative";
+    container.style.marginTop = "8px";
+    const svg = createElementNS("http://www.w3.org/2000/svg", "svg");
+    svg.setAttribute("width", `${width}px`);
+    svg.setAttribute("height", `${height}px`);
+    svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+    svg.style.display = "block";
+    container.appendChild(svg);
+    const g = createElementNS("http://www.w3.org/2000/svg", "g");
+    g.setAttribute("transform", `translate(${margin.left},${margin.top})`);
+    svg.appendChild(g);
+    if (sessionsData.length === 0) {
+        const text = createElementNS("http://www.w3.org/2000/svg", "text");
+        text.setAttribute("x", `${innerWidth / 2}`);
+        text.setAttribute("y", `${innerHeight / 2}`);
+        text.setAttribute("text-anchor", "middle");
+        text.setAttribute("fill", asCssVariable(chartsForeground));
+        text.setAttribute("font-size", "11px");
+        text.textContent = ( localize(9434, "No data yet"));
+        g.appendChild(text);
+        return container;
+    }
+    const xAxisLine = createElementNS("http://www.w3.org/2000/svg", "line");
+    xAxisLine.setAttribute("x1", "0");
+    xAxisLine.setAttribute("y1", `${innerHeight}`);
+    xAxisLine.setAttribute("x2", `${innerWidth}`);
+    xAxisLine.setAttribute("y2", `${innerHeight}`);
+    xAxisLine.setAttribute("stroke", asCssVariable(chartsLines));
+    xAxisLine.setAttribute("stroke-width", "1px");
+    g.appendChild(xAxisLine);
+    const yAxisLine = createElementNS("http://www.w3.org/2000/svg", "line");
+    yAxisLine.setAttribute("x1", "0");
+    yAxisLine.setAttribute("y1", "0");
+    yAxisLine.setAttribute("x2", "0");
+    yAxisLine.setAttribute("y2", `${innerHeight}`);
+    yAxisLine.setAttribute("stroke", asCssVariable(chartsLines));
+    yAxisLine.setAttribute("stroke-width", "1px");
+    g.appendChild(yAxisLine);
+    for (const pct of [0, 50, 100]) {
+        const y = innerHeight - (pct / 100) * innerHeight;
+        const label = createElementNS("http://www.w3.org/2000/svg", "text");
+        label.setAttribute("x", "-4");
+        label.setAttribute("y", `${y + 3}`);
+        label.setAttribute("text-anchor", "end");
+        label.setAttribute("fill", asCssVariable(chartsForeground));
+        label.setAttribute("font-size", "9px");
+        label.textContent = `${pct}%`;
+        g.appendChild(label);
+        if (pct > 0) {
+            const gridLine = createElementNS("http://www.w3.org/2000/svg", "line");
+            gridLine.setAttribute("x1", "0");
+            gridLine.setAttribute("y1", `${y}`);
+            gridLine.setAttribute("x2", `${innerWidth}`);
+            gridLine.setAttribute("y2", `${y}`);
+            gridLine.setAttribute("stroke", asCssVariable(chartsLines));
+            gridLine.setAttribute("stroke-width", "0.5px");
+            gridLine.setAttribute("stroke-dasharray", "2,2");
+            g.appendChild(gridLine);
+        }
+    }
+    if (mode === "days") {
+        renderDaysView();
+    } else {
+        renderSessionsView();
+    }
+    function renderDaysView() {
+        const dailyData = aggregateSessionsByDay(sessionsData);
+        const barCount = dailyData.length;
+        const barWidth = Math.min(20, (innerWidth - (barCount - 1) * 2) / barCount);
+        const gap = 2;
+        const totalBarSpace = barCount * barWidth + (barCount - 1) * gap;
+        const startX = (innerWidth - totalBarSpace) / 2;
+        const minLabelSpacing = 40;
+        const totalWidth = totalBarSpace;
+        const maxLabels = Math.max(2, Math.floor(totalWidth / minLabelSpacing));
+        const labelStep = Math.max(1, Math.ceil(barCount / maxLabels));
+        dailyData.forEach((day, i) => {
+            const x = startX + i * (barWidth + gap);
+            const barHeight = day.aiRate * innerHeight;
+            const y = innerHeight - barHeight;
+            const rect = createElementNS("http://www.w3.org/2000/svg", "rect");
+            rect.setAttribute("x", `${x}`);
+            rect.setAttribute("y", `${y}`);
+            rect.setAttribute("width", `${barWidth}`);
+            rect.setAttribute("height", `${Math.max(1, barHeight)}`);
+            rect.setAttribute("fill", asCssVariable(chartsBlue));
+            rect.setAttribute("rx", "2");
+            g.appendChild(rect);
+            const isFirst = i === 0;
+            const isLast = i === barCount - 1;
+            const isAtInterval = i % labelStep === 0;
+            if (isFirst || isLast || (isAtInterval && barCount > 2)) {
+                if (!isFirst && !isLast) {
+                    const distFromFirst = i * (barWidth + gap);
+                    const distFromLast = (barCount - 1 - i) * (barWidth + gap);
+                    if (distFromFirst < minLabelSpacing || distFromLast < minLabelSpacing) {
+                        return;
+                    }
+                }
+                const label = createElementNS("http://www.w3.org/2000/svg", "text");
+                label.setAttribute("x", `${x + barWidth / 2}`);
+                label.setAttribute("y", `${innerHeight + 12}`);
+                label.setAttribute("text-anchor", "middle");
+                label.setAttribute("fill", asCssVariable(chartsForeground));
+                label.setAttribute("font-size", "8px");
+                label.textContent = day.displayDate;
+                g.appendChild(label);
+            }
+        });
+    }
+    function renderSessionsView() {
+        const sessionCount = sessionsData.length;
+        const barWidth = Math.min(8, (innerWidth - (sessionCount - 1) * 1) / sessionCount);
+        const gap = 1;
+        const totalBarSpace = sessionCount * barWidth + (sessionCount - 1) * gap;
+        const startX = (innerWidth - totalBarSpace) / 2;
+        sessionsData.forEach((session, i) => {
+            const total = session.aiCharacters + session.typedCharacters;
+            const aiRate = total > 0 ? session.aiCharacters / total : 0;
+            const x = startX + i * (barWidth + gap);
+            const barHeight = aiRate * innerHeight;
+            const y = innerHeight - barHeight;
+            const rect = createElementNS("http://www.w3.org/2000/svg", "rect");
+            rect.setAttribute("x", `${x}`);
+            rect.setAttribute("y", `${y}`);
+            rect.setAttribute("width", `${barWidth}`);
+            rect.setAttribute("height", `${Math.max(1, barHeight)}`);
+            rect.setAttribute("fill", asCssVariable(chartsBlue));
+            rect.setAttribute("rx", "1");
+            g.appendChild(rect);
+        });
+        const minLabelSpacing = 40;
+        if (sessionCount === 0) {
+            return;
+        }
+        const firstSession = sessionsData[0];
+        const firstX = startX;
+        const firstDate = ( new Date(firstSession.startTime));
+        const firstLabel = createElementNS("http://www.w3.org/2000/svg", "text");
+        firstLabel.setAttribute("x", `${firstX + barWidth / 2}`);
+        firstLabel.setAttribute("y", `${innerHeight + 12}`);
+        firstLabel.setAttribute("text-anchor", "start");
+        firstLabel.setAttribute("fill", asCssVariable(chartsForeground));
+        firstLabel.setAttribute("font-size", "8px");
+        firstLabel.textContent = firstDate.toLocaleDateString(undefined, {
+            month: "short",
+            day: "numeric"
+        });
+        g.appendChild(firstLabel);
+        if (sessionCount > 1 && totalBarSpace >= minLabelSpacing) {
+            const lastSession = sessionsData[sessionCount - 1];
+            const lastX = startX + (sessionCount - 1) * (barWidth + gap);
+            const lastDate = ( new Date(lastSession.startTime));
+            const lastLabel = createElementNS("http://www.w3.org/2000/svg", "text");
+            lastLabel.setAttribute("x", `${lastX + barWidth / 2}`);
+            lastLabel.setAttribute("y", `${innerHeight + 12}`);
+            lastLabel.setAttribute("text-anchor", "end");
+            lastLabel.setAttribute("fill", asCssVariable(chartsForeground));
+            lastLabel.setAttribute("font-size", "8px");
+            lastLabel.textContent = lastDate.toLocaleDateString(undefined, {
+                month: "short",
+                day: "numeric"
+            });
+            g.appendChild(lastLabel);
+        }
+    }
+    return container;
+}
+
+export { aggregateSessionsByDay, createAiStatsChart };

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

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { AnnotatedDocuments } from "../helpers/annotatedDocuments.js";
+export declare class AiStatsFeature extends Disposable {
+    private readonly _storageService;
+    private readonly _instantiationService;
+    private readonly _data;
+    private readonly _dataVersion;
+    constructor(annotatedDocuments: AnnotatedDocuments, _storageService: IStorageService, _instantiationService: IInstantiationService);
+    readonly aiRate: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservable<number>;
+    readonly sessionCount: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<number, void>;
+    readonly sessions: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<ISession[], void>;
+    readonly acceptedInlineSuggestionsToday: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").IObservableWithChange<number, void>;
+    private _getDataAndSession;
+}
+interface ISession {
+    startTime: number;
+    typedCharacters: number;
+    aiCharacters: number;
+    acceptedInlineSuggestions: number | undefined;
+    chatEditCount: number | undefined;
+}
+export {};