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

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

@@ -0,0 +1,297 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { AsyncReader, AsyncReaderEndOfStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CachedFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cache';
+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 { AnnotatedStringEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { iterateObservableChanges, mapObservableDelta } from './utils.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+class DocumentWithSourceAnnotatedEdits extends Disposable {
+    constructor(_originalDoc) {
+        super();
+        this._originalDoc = _originalDoc;
+        const v = this.value = observableValue(this, _originalDoc.value.get());
+        this._register(runOnChange(this._originalDoc.value, (val, _prevVal, edits) => {
+            const eComposed = AnnotatedStringEdit.compose(( edits.map(e => {
+                const editSourceData = ( new EditSourceData(e.reason));
+                return e.mapData(() => editSourceData);
+            })));
+            v.set(val, undefined, {
+                edit: eComposed
+            });
+        }));
+    }
+    waitForQueue() {
+        return Promise.resolve();
+    }
+}
+class EditSourceData {
+    constructor(editSource) {
+        this.editSource = editSource;
+        this.key = this.editSource.toKey(1);
+        this.source = EditSourceBase.create(this.editSource);
+    }
+    join(data) {
+        if (this.editSource !== data.editSource) {
+            return undefined;
+        }
+        return this;
+    }
+    toEditSourceData() {
+        return ( new EditKeySourceData(this.key, this.source, this.editSource));
+    }
+}
+class EditKeySourceData {
+    constructor(key, source, representative) {
+        this.key = key;
+        this.source = source;
+        this.representative = representative;
+    }
+    join(data) {
+        if (this.key !== data.key) {
+            return undefined;
+        }
+        if (this.source !== data.source) {
+            return undefined;
+        }
+        return this;
+    }
+}
+class EditSourceBase {
+    static {
+        this._cache = ( new CachedFunction({
+            getCacheKey: v => ( v.toString())
+        }, arg => arg));
+    }
+    static create(reason) {
+        const data = reason.metadata;
+        switch (data.source) {
+        case "reloadFromDisk":
+            return this._cache.get(( new ExternalEditSource()));
+        case "inlineCompletionPartialAccept":
+        case "inlineCompletionAccept":
+            {
+                const type = "type" in data ? data.type : undefined;
+                if ("$nes" in data && data.$nes) {
+                    return this._cache.get(( new InlineSuggestEditSource("nes", data.$extensionId ?? "", data.$providerId ?? "", type)));
+                }
+                return this._cache.get(( new InlineSuggestEditSource("completion", data.$extensionId ?? "", data.$providerId ?? "", type)));
+            }
+        case "snippet":
+            return this._cache.get(( new IdeEditSource("suggest")));
+        case "unknown":
+            if (!data.name) {
+                return this._cache.get(( new UnknownEditSource()));
+            }
+            switch (data.name) {
+            case "formatEditsCommand":
+                return this._cache.get(( new IdeEditSource("format")));
+            }
+            return this._cache.get(( new UnknownEditSource()));
+        case "Chat.applyEdits":
+            return this._cache.get(( new ChatEditSource("sidebar")));
+        case "inlineChat.applyEdits":
+            return this._cache.get(( new ChatEditSource("inline")));
+        case "cursor":
+            return this._cache.get(( new UserEditSource()));
+        default:
+            return this._cache.get(( new UnknownEditSource()));
+        }
+    }
+}
+class InlineSuggestEditSource extends EditSourceBase {
+    constructor(kind, extensionId, providerId, type) {
+        super();
+        this.kind = kind;
+        this.extensionId = extensionId;
+        this.providerId = providerId;
+        this.type = type;
+        this.category = "ai";
+        this.feature = "inlineSuggest";
+    }
+    toString() {
+        return `${this.category}/${this.feature}/${this.kind}/${this.extensionId}/${this.type}`;
+    }
+    getColor() {
+        return "#00ff0033";
+    }
+}
+class ChatEditSource extends EditSourceBase {
+    constructor(kind) {
+        super();
+        this.kind = kind;
+        this.category = "ai";
+        this.feature = "chat";
+    }
+    toString() {
+        return `${this.category}/${this.feature}/${this.kind}`;
+    }
+    getColor() {
+        return "#00ff0066";
+    }
+}
+class IdeEditSource extends EditSourceBase {
+    constructor(feature) {
+        super();
+        this.feature = feature;
+        this.category = "ide";
+    }
+    toString() {
+        return `${this.category}/${this.feature}`;
+    }
+    getColor() {
+        return this.feature === "format" ? "#0000ff33" : "#80808033";
+    }
+}
+class UserEditSource extends EditSourceBase {
+    constructor() {
+        super();
+        this.category = "user";
+    }
+    toString() {
+        return this.category;
+    }
+    getColor() {
+        return "#d3d3d333";
+    }
+}
+class ExternalEditSource extends EditSourceBase {
+    constructor() {
+        super();
+        this.category = "external";
+    }
+    toString() {
+        return this.category;
+    }
+    getColor() {
+        return "#009ab254";
+    }
+}
+class UnknownEditSource extends EditSourceBase {
+    constructor() {
+        super();
+        this.category = "unknown";
+    }
+    toString() {
+        return this.category;
+    }
+    getColor() {
+        return "#ff000033";
+    }
+}
+let CombineStreamedChanges = class CombineStreamedChanges extends Disposable {
+    constructor(_originalDoc, _instantiationService) {
+        super();
+        this._originalDoc = _originalDoc;
+        this._instantiationService = _instantiationService;
+        this._runStore = this._register(( new DisposableStore()));
+        this._runQueue = Promise.resolve();
+        this._diffService = this._instantiationService.createInstance(DiffService);
+        this.value = this._value = observableValue(this, _originalDoc.value.get());
+        this._restart();
+    }
+    async _restart() {
+        this._runStore.clear();
+        const iterator = iterateObservableChanges(this._originalDoc.value, this._runStore)[Symbol.asyncIterator]();
+        const p = this._runQueue;
+        this._runQueue = this._runQueue.then(() => this._run(iterator));
+        await p;
+    }
+    async _run(iterator) {
+        const reader = ( new AsyncReader(iterator));
+        while (true) {
+            let peeked = await reader.peek();
+            if (peeked === AsyncReaderEndOfStream) {
+                return;
+            } else if (isChatEdit(peeked)) {
+                const first = peeked;
+                let last = first;
+                let chatEdit = AnnotatedStringEdit.empty;
+                do {
+                    reader.readBufferedOrThrow();
+                    last = peeked;
+                    chatEdit = chatEdit.compose(AnnotatedStringEdit.compose(( peeked.change.map(c => c.edit))));
+                    const peekedOrUndefined = await reader.peekTimeout(1000);
+                    if (!peekedOrUndefined) {
+                        break;
+                    }
+                    peeked = peekedOrUndefined;
+                } while (peeked !== AsyncReaderEndOfStream && isChatEdit(peeked));
+                if (!chatEdit.isEmpty()) {
+                    const data = chatEdit.replacements[0].data;
+                    const diffEdit = await this._diffService.computeDiff(first.prevValue.value, last.value.value);
+                    const edit = diffEdit.mapData(_e => data);
+                    this._value.set(last.value, undefined, {
+                        edit
+                    });
+                }
+            } else {
+                reader.readBufferedOrThrow();
+                const e = AnnotatedStringEdit.compose(( peeked.change.map(c => c.edit)));
+                this._value.set(peeked.value, undefined, {
+                    edit: e
+                });
+            }
+        }
+    }
+    async waitForQueue() {
+        await this._originalDoc.waitForQueue();
+        await this._restart();
+    }
+};
+CombineStreamedChanges = ( __decorate([( __param(1, IInstantiationService))], CombineStreamedChanges));
+let DiffService = class DiffService {
+    constructor(_editorWorkerService) {
+        this._editorWorkerService = _editorWorkerService;
+    }
+    async computeDiff(original, modified) {
+        const diffEdit = await this._editorWorkerService.computeStringEditFromDiff(original, modified, {
+            maxComputationTimeMs: 500
+        }, "advanced");
+        return diffEdit;
+    }
+};
+DiffService = ( __decorate([( __param(0, IEditorWorkerService))], DiffService));
+function isChatEdit(next) {
+    return next.change.every(c => c.edit.replacements.every(e => {
+        if (e.data.source.category === "ai" && e.data.source.feature === "chat") {
+            return true;
+        }
+        return false;
+    }));
+}
+class MinimizeEditsProcessor extends Disposable {
+    constructor(_originalDoc) {
+        super();
+        this._originalDoc = _originalDoc;
+        const v = this.value = observableValue(this, _originalDoc.value.get());
+        let prevValue = this._originalDoc.value.get().value;
+        this._register(runOnChange(this._originalDoc.value, (val, _prevVal, edits) => {
+            const eComposed = AnnotatedStringEdit.compose(( edits.map(e => e.edit)));
+            const e = eComposed.removeCommonSuffixAndPrefix(prevValue);
+            prevValue = val.value;
+            v.set(val, undefined, {
+                edit: e
+            });
+        }));
+    }
+    async waitForQueue() {
+        await this._originalDoc.waitForQueue();
+    }
+}
+function createDocWithJustReason(docWithAnnotatedEdits, store) {
+    const docWithJustReason = {
+        value: mapObservableDelta(docWithAnnotatedEdits.value, edit => ({
+            edit: edit.edit.mapData(d => d.data.toEditSourceData())
+        }), store),
+        waitForQueue: () => docWithAnnotatedEdits.waitForQueue()
+    };
+    return docWithJustReason;
+}
+
+export { CombineStreamedChanges, DiffService, DocumentWithSourceAnnotatedEdits, EditKeySourceData, EditSourceBase, EditSourceData, InlineSuggestEditSource, MinimizeEditsProcessor, createDocWithJustReason };

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

@@ -0,0 +1,31 @@
+import { IObservableWithChange, IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { StringEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit";
+import { OffsetRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange";
+import { StringText } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/abstractText";
+import { TextModelEditSource } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource";
+export declare abstract class ObservableWorkspace {
+    abstract get documents(): IObservable<readonly IObservableDocument[]>;
+    getFirstOpenDocument(): IObservableDocument | undefined;
+    getDocument(documentId: URI): IObservableDocument | undefined;
+    private _version;
+    /**
+     * Is fired when any open document changes.
+    */
+    readonly onDidOpenDocumentChange: IObservableWithChange<number, unknown>;
+    readonly lastActiveDocument: IObservable<IObservableDocument | undefined>;
+}
+export interface IObservableDocument {
+    readonly uri: URI;
+    readonly value: IObservableWithChange<StringText, StringEditWithReason>;
+    /**
+     * Increases whenever the value changes. Is also used to reference document states from the past.
+    */
+    readonly version: IObservable<number>;
+    readonly languageId: IObservable<string>;
+}
+export declare class StringEditWithReason extends StringEdit {
+    readonly reason: TextModelEditSource;
+    static replace(range: OffsetRange, newText: string, source?: TextModelEditSource): StringEditWithReason;
+    constructor(replacements: StringEdit["replacements"], reason: TextModelEditSource);
+}

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

@@ -0,0 +1,66 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { StringEdit, StringReplacement } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit';
+import { EditSources } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource';
+import { derivedHandleChanges, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+
+class ObservableWorkspace {
+    constructor() {
+        this._version = 0;
+        this.onDidOpenDocumentChange = derivedHandleChanges({
+            owner: this,
+            changeTracker: {
+                createChangeSummary: () => ({
+                    didChange: false
+                }),
+                handleChange: (ctx, changeSummary) => {
+                    if (!ctx.didChange(this.documents)) {
+                        changeSummary.didChange = true;
+                    }
+                    return true;
+                }
+            }
+        }, (reader, changeSummary) => {
+            const docs = this.documents.read(reader);
+            for (const d of docs) {
+                d.value.read(reader);
+            }
+            if (changeSummary.didChange) {
+                this._version++;
+            }
+            return this._version;
+        });
+        this.lastActiveDocument = derived(reader => {
+            const obs = observableValue("lastActiveDocument", undefined);
+            reader.store.add(autorun(reader => {
+                const docs = this.documents.read(reader);
+                for (const d of docs) {
+                    reader.store.add(runOnChange(d.value, () => {
+                        obs.set(d, undefined);
+                    }));
+                }
+            }));
+            return obs;
+        }).flatten();
+    }
+    getFirstOpenDocument() {
+        return this.documents.get()[0];
+    }
+    getDocument(documentId) {
+        return this.documents.get().find(d => ( d.uri.toString()) === ( documentId.toString()));
+    }
+}
+class StringEditWithReason extends StringEdit {
+    static replace(range, newText, source = EditSources.unknown({})) {
+        return ( new StringEditWithReason([( new StringReplacement(range, newText))], source));
+    }
+    constructor(replacements, reason) {
+        super(replacements);
+        this.reason = reason;
+    }
+}
+
+export { ObservableWorkspace, StringEditWithReason };

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

@@ -0,0 +1,9 @@
+import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservableWithChange, RemoveUndefined } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+export declare function sumByCategory<T, TCategory extends string>(items: readonly T[], getValue: (item: T) => number, getCategory: (item: T) => TCategory): Record<TCategory, number | undefined>;
+export declare function mapObservableDelta<T, TDelta, TDeltaNew>(obs: IObservableWithChange<T, TDelta>, mapFn: (value: TDelta) => TDeltaNew, store: DisposableStore): IObservableWithChange<T, TDeltaNew>;
+export declare function iterateObservableChanges<T, TChange>(obs: IObservableWithChange<T, TChange>, store: DisposableStore): AsyncIterable<{
+    value: T;
+    prevValue: T;
+    change: RemoveUndefined<TChange>[];
+}>;

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

@@ -0,0 +1,47 @@
+
+import { AsyncIterableProducer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+function sumByCategory(items, getValue, getCategory) {
+    return items.reduce((acc, item) => {
+        const category = getCategory(item);
+        acc[category] = (acc[category] || 0) + getValue(item);
+        return acc;
+    }, {});
+}
+function mapObservableDelta(obs, mapFn, store) {
+    const obsResult = observableValue("mapped", obs.get());
+    store.add(runOnChange(obs, (value, _prevValue, changes) => {
+        transaction(tx => {
+            for (const c of changes) {
+                obsResult.set(value, tx, mapFn(c));
+            }
+        });
+    }));
+    return obsResult;
+}
+function iterateObservableChanges(obs, store) {
+    return new AsyncIterableProducer(e => {
+        if (store.isDisposed) {
+            return;
+        }
+        store.add(runOnChange(obs, (value, prevValue, change) => {
+            e.emitOne({
+                value,
+                prevValue,
+                change: change
+            });
+        }));
+        return ( new Promise(res => {
+            store.add(toDisposable(() => {
+                res(undefined);
+            }));
+        }));
+    });
+}
+
+export { iterateObservableChanges, mapObservableDelta, sumByCategory };

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

@@ -0,0 +1,26 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, IObservableWithChange } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { StringText } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/abstractText";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IObservableDocument, ObservableWorkspace, StringEditWithReason } from "./observableWorkspace.js";
+export declare class VSCodeWorkspace extends ObservableWorkspace implements IDisposable {
+    private readonly _textModelService;
+    private readonly _documents;
+    get documents(): IObservable<VSCodeDocument[]>;
+    private readonly _store;
+    constructor(_textModelService: IModelService);
+    dispose(): void;
+}
+export declare class VSCodeDocument extends Disposable implements IObservableDocument {
+    readonly textModel: ITextModel;
+    get uri(): URI;
+    private readonly _value;
+    private readonly _version;
+    private readonly _languageId;
+    get value(): IObservableWithChange<StringText, StringEditWithReason>;
+    get version(): IObservable<number>;
+    get languageId(): IObservable<string>;
+    constructor(textModel: ITextModel);
+}

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

@@ -0,0 +1,84 @@
+
+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 { DisposableStore, 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 { StringText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/text/abstractText';
+import { offsetEditFromContentChanges } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelStringEdit';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ObservableWorkspace, StringEditWithReason } from './observableWorkspace.js';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+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';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+let VSCodeWorkspace = class VSCodeWorkspace extends ObservableWorkspace {
+    get documents() {
+        return this._documents;
+    }
+    constructor(_textModelService) {
+        super();
+        this._textModelService = _textModelService;
+        this._store = ( new DisposableStore());
+        const onModelAdded = observableSignalFromEvent(this, this._textModelService.onModelAdded);
+        const onModelRemoved = observableSignalFromEvent(this, this._textModelService.onModelRemoved);
+        const models = derived(this, reader => {
+            onModelAdded.read(reader);
+            onModelRemoved.read(reader);
+            const models = this._textModelService.getModels();
+            return models;
+        });
+        const documents = ( mapObservableArrayCached(this, models, (m, store) => {
+            if (m.isTooLargeForSyncing()) {
+                return undefined;
+            }
+            return store.add(( new VSCodeDocument(m)));
+        }).recomputeInitiallyAndOnChange(this._store).map(d => d.filter(isDefined)));
+        this._documents = documents;
+    }
+    dispose() {
+        this._store.dispose();
+    }
+};
+VSCodeWorkspace = ( __decorate([( __param(0, IModelService))], VSCodeWorkspace));
+class VSCodeDocument extends Disposable {
+    get uri() {
+        return this.textModel.uri;
+    }
+    get value() {
+        return this._value;
+    }
+    get version() {
+        return this._version;
+    }
+    get languageId() {
+        return this._languageId;
+    }
+    constructor(textModel) {
+        super();
+        this.textModel = textModel;
+        this._value = observableValue(this, ( new StringText(this.textModel.getValue())));
+        this._version = observableValue(this, this.textModel.getVersionId());
+        this._languageId = observableValue(this, this.textModel.getLanguageId());
+        this._register(this.textModel.onDidChangeContent(e => {
+            transaction(tx => {
+                const edit = offsetEditFromContentChanges(e.changes);
+                if (e.detailedReasons.length !== 1) {
+                    onUnexpectedError(( new Error(`Unexpected number of detailed reasons: ${e.detailedReasons.length}`)));
+                }
+                const change = ( new StringEditWithReason(edit.replacements, e.detailedReasons[0]));
+                this._value.set(( new StringText(this.textModel.getValue())), tx, change);
+                this._version.set(this.textModel.getVersionId(), tx);
+            });
+        }));
+        this._register(this.textModel.onDidChangeLanguage(e => {
+            transaction(tx => {
+                this._languageId.set(this.textModel.getLanguageId(), tx);
+            });
+        }));
+    }
+}
+
+export { VSCodeDocument, VSCodeWorkspace };

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

@@ -0,0 +1,2 @@
+export declare const EDIT_TELEMETRY_SETTING_ID = "telemetry.editStats.enabled";
+export declare const AI_STATS_SETTING_ID = "editor.aiStats.enabled";

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

@@ -0,0 +1,6 @@
+
+
+const EDIT_TELEMETRY_SETTING_ID = 'telemetry.editStats.enabled';
+const AI_STATS_SETTING_ID = 'editor.aiStats.enabled';
+
+export { AI_STATS_SETTING_ID, EDIT_TELEMETRY_SETTING_ID };

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

@@ -0,0 +1,3 @@
+export declare const EDIT_TELEMETRY_DETAILS_SETTING_ID = "telemetry.editStats.details.enabled";
+export declare const EDIT_TELEMETRY_SHOW_DECORATIONS = "telemetry.editStats.showDecorations";
+export declare const EDIT_TELEMETRY_SHOW_STATUS_BAR = "telemetry.editStats.showStatusBar";

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

@@ -0,0 +1,7 @@
+
+
+const EDIT_TELEMETRY_DETAILS_SETTING_ID = 'telemetry.editStats.details.enabled';
+const EDIT_TELEMETRY_SHOW_DECORATIONS = 'telemetry.editStats.showDecorations';
+const EDIT_TELEMETRY_SHOW_STATUS_BAR = 'telemetry.editStats.showStatusBar';
+
+export { EDIT_TELEMETRY_DETAILS_SETTING_ID, EDIT_TELEMETRY_SHOW_DECORATIONS, EDIT_TELEMETRY_SHOW_STATUS_BAR };

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

@@ -0,0 +1,37 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservableWithChange, IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { BaseStringEdit } 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 { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import type { ScmRepoAdapter } from "./scmAdapter.js";
+export declare class ArcTelemetryReporter extends Disposable {
+    private readonly _timesMs;
+    private readonly _documentValueBeforeTrackedEdit;
+    private readonly _document;
+    private readonly _gitRepo;
+    private readonly _trackedEdit;
+    private readonly _sendTelemetryEvent;
+    private readonly _dispose;
+    private readonly _telemetryService;
+    private readonly _arcTracker;
+    private readonly _initialBranchName;
+    private readonly _initialLineCounts;
+    constructor(_timesMs: number[], _documentValueBeforeTrackedEdit: StringText, _document: {
+        value: IObservableWithChange<StringText, {
+            edit: BaseStringEdit;
+        }>;
+    }, _gitRepo: IObservable<ScmRepoAdapter | undefined>, _trackedEdit: BaseStringEdit, _sendTelemetryEvent: (res: ArcTelemetryReporterData) => void, _dispose: () => void, _telemetryService: ITelemetryService);
+    private _reportAfter;
+    private _report;
+}
+export interface ArcTelemetryReporterData {
+    telemetryService: ITelemetryService;
+    timeDelayMs: number;
+    didBranchChange: boolean;
+    arc: number;
+    originalCharCount: number;
+    currentLineCount: number;
+    currentDeletedLineCount: number;
+    originalLineCount: number;
+    originalDeletedLineCount: number;
+}