feat(auto-edits): adding autoedits onboarding setup for dotcom users

agent/src/AgentWorkspaceConfiguration.test.ts

@@ -72,7 +72,7 @@ describe('AgentWorkspaceConfiguration', () => {
             expect(config.get('cody.telemetry.level')).toBe('agent')
             // clientName undefined because custom JSON specified telemetry with level alone.
             expect(config.get('cody.telemetry.clientName')).toBe('test-client')
-            expect(config.get('cody.autocomplete.enabled')).toBe(true)
+            expect(config.get('cody.suggestions.mode')).toBe('autocomplete')
             expect(config.get('cody.autocomplete.advanced.provider')).toBe('anthropic')
             expect(config.get('cody.autocomplete.advanced.model')).toBe('claude-2')
             expect(config.get('cody.advanced.agent.running')).toBe(true)

jetbrains/src/test/kotlin/com/sourcegraph/config/ConfigUtilTest.kt

@@ -16,7 +16,7 @@ class ConfigUtils {
         """
     {
       "cody.debug": true,
-      "cody.autocomplete.enabled": true
+      "cody.suggestions.mode": "autocomplete"
     }
     """
     val result = ConfigUtil.getCustomConfiguration(mockProject, input)
@@ -39,7 +39,7 @@ class ConfigUtils {
         """
     {
       "cody.debug": true,
-      "cody.autocomplete.enabled": true,
+      "cody.suggestions.mode": "autocomplete"
     }
     """
     val result = ConfigUtil.getCustomConfiguration(mockProject, input)
@@ -55,7 +55,7 @@ class ConfigUtils {
     {
        // This is a comment
       "cody.debug": true,
-      "cody.autocomplete.enabled": true,
+      "cody.suggestions.mode": "autocomplete"
     }
     """
     val result = ConfigUtil.getCustomConfiguration(mockProject, input)

lib/shared/src/configuration.ts

@@ -107,7 +107,7 @@ interface RawClientConfiguration {
     experimentalSupercompletions: boolean
     experimentalAutoeditsRendererTesting: boolean
     experimentalAutoeditsConfigOverride: AutoEditsModelConfig | undefined
-    experimentalAutoeditsEnabled: boolean | undefined
+    experimentalAutoeditsEnabled: boolean
     experimentalCommitMessage: boolean
     experimentalNoodle: boolean
     experimentalMinionAnthropicKey: string | undefined
@@ -188,6 +188,24 @@ export enum CodyIDE {
     StandaloneWeb = 'StandaloneWeb',
 }
 
+/**
+ * These values must match the enum values in cody.suggestions.mode in vscode/package.json
+ */
+export enum CodyAutoSuggestionMode {
+    /**
+     * The suggestion mode where suggestions come from the OpenAI completions API. This is the default mode.
+     */
+    Autocomplete = 'autocomplete',
+    /**
+     * The suggestion mode where suggestions come from the Cody AI agent chat API.
+     */
+    Autoedits = 'auto-edits (Experimental)',
+    /**
+     * Disable Cody suggestions altogether.
+     */
+    Off = 'off',
+}
+
 export type AutocompleteProviderID = keyof typeof AUTOCOMPLETE_PROVIDER_ID
 
 export const AUTOCOMPLETE_PROVIDER_ID = {

vscode/package.json

@@ -409,13 +409,13 @@
         "command": "cody.autocomplete.openTraceView",
         "category": "Cody",
         "title": "Open Autocomplete Trace View",
-        "enablement": "cody.activated && config.cody.autocomplete.enabled"
+        "enablement": "cody.activated && config.cody.suggestions.mode === 'autocomplete'"
       },
       {
         "command": "cody.autocomplete.manual-trigger",
         "category": "Cody",
         "title": "Trigger Autocomplete at Cursor",
-        "enablement": "cody.activated && config.cody.autocomplete.enabled && !editorReadonly && !editorHasSelection && !inlineSuggestionsVisible"
+        "enablement": "cody.activated && config.cody.suggestions.mode === 'autocomplete' && !editorReadonly && !editorHasSelection && !inlineSuggestionsVisible"
       },
       {
         "command": "cody.chat.signIn",
@@ -578,7 +578,7 @@
       {
         "command": "cody.command.autoedits-manual-trigger",
         "title": "Autoedits Manual Trigger",
-        "enablement": "cody.activated && config.cody.experimental.autoedits.enabled"
+        "enablement": "cody.activated && config.cody.suggestions.mode == 'auto-edits (Experimental)'"
       }
     ],
     "keybindings": [
@@ -687,7 +687,7 @@
       {
         "command": "cody.autocomplete.manual-trigger",
         "key": "alt+\\",
-        "when": "editorTextFocus && !editorHasSelection && config.cody.autocomplete.enabled && !inlineSuggestionsVisible"
+        "when": "editorTextFocus && !editorHasSelection && config.cody.suggestions.mode === 'autocomplete' && !inlineSuggestionsVisible"
       },
       {
         "command": "cody.fixup.acceptNearest",
@@ -739,7 +739,7 @@
       {
         "command": "cody.supersuggest.testExample",
         "key": "ctrl+alt+enter",
-        "when": "cody.activated && config.cody.experimental.autoedits.enabled"
+        "when": "cody.activated && config.cody.suggestions.mode == 'auto-edits (Experimental)'"
       }
     ],
     "submenus": [
@@ -1001,11 +1001,16 @@
             }
           ]
         },
-        "cody.autocomplete.enabled": {
-          "order": 5,
-          "type": "boolean",
-          "markdownDescription": "Enables code autocompletions.",
-          "default": true
+        "cody.suggestions.mode": {
+          "type": "string",
+          "enum": ["autocomplete", "auto-edits (Experimental)", "off"],
+          "enumDescriptions": [
+            "Suggests standard code completions as you type.",
+            "Suggests advanced context-aware code edits as you navigate the codebase. Experimental feature for Pro and Enterprise users.",
+            "Disables all suggestions."
+          ],
+          "default": "autocomplete",
+          "markdownDescription": "Controls the suggestion mode for Cody"
         },
         "cody.autocomplete.triggerDelay": {
           "order": 5,

vscode/src/autoedits/autoedit-onboarding.ts

@@ -0,0 +1,96 @@
+import {
+    FeatureFlag,
+    currentAuthStatus,
+    currentResolvedConfig,
+    currentUserProductSubscription,
+    featureFlagProvider,
+    storeLastValue,
+} from '@sourcegraph/cody-shared'
+import * as vscode from 'vscode'
+import { localStorage } from '../services/LocalStorageProvider'
+import { isUserEligibleForAutoeditsFeature } from './create-autoedits-provider'
+
+export class AutoeditsOnboarding implements vscode.Disposable {
+    private readonly MAX_AUTO_EDITS_ONBOARDING_NOTIFICATIONS = 3
+
+    private featureFlagAutoeditsExperimental = storeLastValue(
+        featureFlagProvider.evaluatedFeatureFlag(FeatureFlag.CodyAutoeditExperimentEnabledFeatureFlag)
+    )
+
+    public async showAutoeditsOnboardingIfEligible(): Promise<void> {
+        const shouldShowOnboardingPopup = await this.shouldShowAutoeditsOnboardingPopup()
+        if (shouldShowOnboardingPopup) {
+            await this.showAutoeditsOnboardingPopup()
+            await this.incrementAutoEditsOnboardingNotificationCount()
+        }
+    }
+
+    private async showAutoeditsOnboardingPopup(): Promise<void> {
+        const selection = await vscode.window.showInformationMessage(
+            '✨ Try Cody auto-edits: Experimental feature which suggests advanced context-aware code edits as you navigate the codebase',
+            'Enable auto-edits'
+        )
+
+        if (selection === 'Enable auto-edits') {
+            // Enable the setting programmatically
+            await vscode.workspace
+                .getConfiguration()
+                .update(
+                    'cody.suggestions.mode',
+                    'auto-edits (Experimental)',
+                    vscode.ConfigurationTarget.Global
+                )
+
+            // Open VS Code settings UI and focus on the Cody Autoedits setting
+            await vscode.commands.executeCommand(
+                'workbench.action.openSettings',
+                'cody.suggestions.mode'
+            )
+        }
+    }
+
+    private async shouldShowAutoeditsOnboardingPopup(): Promise<boolean> {
+        const isUserEligible = await this.isUserEligibleForAutoeditsOnboarding()
+        const isAutoeditsDisabled = await this.isAutoeditsDisabled()
+        const isUnderNotificationLimit = await this.isAutoeditsNotificationsUnderLimit()
+        return isUserEligible && isAutoeditsDisabled && isUnderNotificationLimit
+    }
+
+    private async incrementAutoEditsOnboardingNotificationCount(): Promise<void> {
+        const count = await this.getAutoEditsOnboardingNotificationCount()
+        await localStorage.setAutoEditsOnboardingNotificationCount(count + 1)
+    }
+
+    private async isAutoeditsDisabled(): Promise<boolean> {
+        const config = await currentResolvedConfig()
+        return !config.configuration.experimentalAutoeditsEnabled
+    }
+
+    private async isAutoeditsNotificationsUnderLimit(): Promise<boolean> {
+        const count = await this.getAutoEditsOnboardingNotificationCount()
+        return count < this.MAX_AUTO_EDITS_ONBOARDING_NOTIFICATIONS
+    }
+
+    private async getAutoEditsOnboardingNotificationCount(): Promise<number> {
+        return await localStorage.getAutoEditsOnboardingNotificationCount()
+    }
+
+    private async isUserEligibleForAutoeditsOnboarding(): Promise<boolean> {
+        const authStatus = currentAuthStatus()
+        const productSubsubscription = await currentUserProductSubscription()
+        const autoeditsFeatureFlag = this.isAutoeditsFeatureFlagEnabled()
+        return isUserEligibleForAutoeditsFeature(
+            autoeditsFeatureFlag,
+            authStatus,
+            productSubsubscription
+        )
+    }
+
+    private isAutoeditsFeatureFlagEnabled(): boolean {
+        return !!this.featureFlagAutoeditsExperimental.value.last
+    }
+
+    dispose(): void {
+        this.featureFlagAutoeditsExperimental.subscription.unsubscribe()
+    }
+}

vscode/src/autoedits/create-autoedits-provider.ts

@@ -0,0 +1,96 @@
+import { type Observable, map } from 'observable-fns'
+import * as vscode from 'vscode'
+
+import {
+    type AuthStatus,
+    type ChatClient,
+    NEVER,
+    type PickResolvedConfiguration,
+    type UserProductSubscription,
+    combineLatest,
+    createDisposables,
+    currentUserProductSubscription,
+    promiseFactoryToObservable,
+    skipPendingOperation,
+} from '@sourcegraph/cody-shared'
+import { isFreeUser } from '@sourcegraph/cody-shared/src/auth/types'
+import { isRunningInsideAgent } from '../jsonrpc/isRunningInsideAgent'
+import { AutoeditsProvider } from './autoedits-provider'
+import { autoeditsOutputChannelLogger } from './output-channel-logger'
+
+interface AutoeditsItemProviderArgs {
+    config: PickResolvedConfiguration<{ configuration: true }>
+    authStatus: AuthStatus
+    chatClient: ChatClient
+    autoeditsFeatureFlagEnabled: boolean
+}
+
+export function createAutoEditsProvider({
+    config: { configuration },
+    authStatus,
+    chatClient,
+    autoeditsFeatureFlagEnabled,
+}: AutoeditsItemProviderArgs): Observable<void> {
+    if (!configuration.experimentalAutoeditsEnabled) {
+        return NEVER
+    }
+
+    if (!authStatus.authenticated) {
+        if (!authStatus.pendingValidation) {
+            autoeditsOutputChannelLogger.logDebug('createProvider', 'You are not signed in.')
+        }
+        return NEVER
+    }
+
+    return combineLatest(
+        promiseFactoryToObservable(async () => await currentUserProductSubscription()),
+        promiseFactoryToObservable(async () => await getAutoeditsProviderDocumentFilters())
+    ).pipe(
+        skipPendingOperation(),
+        createDisposables(([userProductSubscription, documentFilters]) => {
+            if (
+                !isUserEligibleForAutoeditsFeature(
+                    autoeditsFeatureFlagEnabled,
+                    authStatus,
+                    userProductSubscription
+                )
+            ) {
+                throw new Error(
+                    'User is not eligible for auto-edits. Can not initialize auto-edits provider.'
+                )
+            }
+
+            const provider = new AutoeditsProvider(chatClient)
+            return [
+                vscode.commands.registerCommand('cody.command.autoedits-manual-trigger', async () => {
+                    await vscode.commands.executeCommand('editor.action.inlineSuggest.hide')
+                    await vscode.commands.executeCommand('editor.action.inlineSuggest.trigger')
+                }),
+                vscode.languages.registerInlineCompletionItemProvider(documentFilters, provider),
+                provider,
+            ]
+        }),
+        map(() => undefined)
+    )
+}
+
+export async function getAutoeditsProviderDocumentFilters(): Promise<vscode.DocumentFilter[]> {
+    return [{ scheme: 'file', language: '*' }, { notebookType: '*' }]
+}
+
+export function isUserEligibleForAutoeditsFeature(
+    autoeditsFeatureFlagEnabled: boolean,
+    authStatus: AuthStatus,
+    productSubsubscription: UserProductSubscription | null
+): boolean {
+    // Editors other than vscode are not eligible for auto-edits
+    if (isRunningInsideAgent()) {
+        return false
+    }
+    // Free users are not eligible for auto-edits
+    if (isFreeUser(authStatus, productSubsubscription)) {
+        return false
+    }
+    // Users with autoedits feature flag enabled are eligible for auto-edits
+    return autoeditsFeatureFlagEnabled
+}

vscode/src/completions/create-inline-completion-item-provider.ts

@@ -41,7 +41,7 @@ export function createInlineCompletionItemProvider({
         ) {
             throw new Error(
                 'The setting `config.autocomplete` evaluated to `false`. It must be true when running inside the agent. ' +
-                    'To fix this problem, make sure that the setting cody.autocomplete.enabled has the value true.'
+                    'To fix this problem, make sure that the setting cody.suggestions.mode has the value autocomplete.'
             )
         }
         return NEVER

vscode/src/completions/inline-completion-item-provider.ts

@@ -21,6 +21,7 @@ import { autocompleteStageCounterLogger } from '../services/autocomplete-stage-c
 import { recordExposedExperimentsToSpan } from '../services/open-telemetry/utils'
 import { isInTutorial } from '../tutorial/helpers'
 
+import { AutoeditsOnboarding } from '../autoedits/autoedit-onboarding'
 import { ContextRankingStrategy } from '../completions/context/completions-context-ranker'
 import type { CompletionBookkeepingEvent, CompletionItemID, CompletionLogID } from './analytics-logger'
 import * as CompletionAnalyticsLogger from './analytics-logger'
@@ -138,6 +139,12 @@ export class InlineCompletionItemProvider
         tracer = null,
         ...config
     }: CodyCompletionItemProviderConfig) {
+        // Show the autoedits onboarding message if the user hasn't enabled autoedits
+        // but is eligible to use them as an alternative to autocomplete
+        const autoeditsOnboarding = new AutoeditsOnboarding()
+        autoeditsOnboarding.showAutoeditsOnboardingIfEligible()
+        this.disposables.push(autoeditsOnboarding)
+
         // This is a static field to allow for easy access in the static `configuration` getter.
         // There must only be one instance of this class at a time.
         InlineCompletionItemProviderConfigSingleton.set({