[AXON-1488] chore: refactor command usage in rovodev (#1302)

Author: sdzh-atlassian

src/commandContext.ts

@@ -11,8 +11,6 @@ export enum CommandContext {
     JiraLoginTree = 'atlascode:jiraLoginTreeEnabled',
     IsJiraAuthenticated = 'atlascode:isJiraAuthenticated',
     IsBBAuthenticated = 'atlascode:isBBAuthenticated',
-    RovoDevEnabled = 'atlascode:rovoDevEnabled',
-    RovoDevTerminalEnabled = 'atlascode:rovoDevTerminalEnabled',
     BbyEnvironmentActive = 'atlascode:bbyEnvironmentActive',
     DebugMode = 'atlascode:debugMode',
     UseNewAuthFlow = 'atlascode:useNewAuthFlow',

src/commands.ts

@@ -27,6 +27,7 @@ import { ConfigSection, ConfigSubSection, ConfigV3Section, ConfigV3SubSection }
 import { Logger } from './logger';
 import { runQuickAuth } from './onboarding/quickFlow';
 import { AuthenticationType } from './onboarding/quickFlow/authentication/types';
+import { RovodevCommands } from './rovo-dev/api/componentApi';
 import { RovoDevProcessManager } from './rovo-dev/rovoDevProcessManager';
 import { RovoDevContextItem } from './rovo-dev/rovoDevTypes';
 import { openRovoDevConfigFile } from './rovo-dev/rovoDevUtils';
@@ -489,7 +490,7 @@ const buildContext = (editor?: TextEditor, vscodeContext?: ExtensionContext): Ro
 
 export function registerRovoDevCommands(vscodeContext: ExtensionContext) {
     vscodeContext.subscriptions.push(
-        commands.registerCommand(Commands.RovodevAskInteractive, async () => {
+        commands.registerCommand(RovodevCommands.RovodevAskInteractive, async () => {
             const context = buildContext(window.activeTextEditor, vscodeContext);
 
             const prompt = await window.showInputBox({
@@ -502,17 +503,17 @@ export function registerRovoDevCommands(vscodeContext: ExtensionContext) {
             }
             Container.rovodevWebviewProvider.invokeRovoDevAskCommand(prompt, context);
         }),
-        commands.registerCommand(Commands.RovodevAsk, (prompt: string, context?: RovoDevContextItem[]) => {
+        commands.registerCommand(RovodevCommands.RovodevAsk, (prompt: string, context?: RovoDevContextItem[]) => {
             Container.rovodevWebviewProvider.invokeRovoDevAskCommand(prompt, context);
         }),
-        commands.registerCommand(Commands.RovodevNewSession, () => {
+        commands.registerCommand(RovodevCommands.RovodevNewSession, () => {
             Container.rovodevWebviewProvider.executeNewSession();
         }),
-        commands.registerCommand(Commands.RovodevShowTerminal, () => RovoDevProcessManager.showTerminal()),
-        commands.registerCommand(Commands.RovodevShareFeedback, () =>
+        commands.registerCommand(RovodevCommands.RovodevShowTerminal, () => RovoDevProcessManager.showTerminal()),
+        commands.registerCommand(RovodevCommands.RovodevShareFeedback, () =>
             Container.rovodevWebviewProvider.executeTriggerFeedback(),
         ),
-        commands.registerCommand(Commands.RovodevAddToContext, async () => {
+        commands.registerCommand(RovodevCommands.RovodevAddToContext, async () => {
             const context = buildContext(window.activeTextEditor, vscodeContext);
             if (!context || context.length === 0) {
                 // Do nothing, this should only have effect in editor context
@@ -523,13 +524,22 @@ export function registerRovoDevCommands(vscodeContext: ExtensionContext) {
                 Container.rovodevWebviewProvider.addToContext(item);
             });
         }),
-        commands.registerCommand(Commands.OpenRovoDevConfig, async () => await openRovoDevConfigFile('config.yml')),
-        commands.registerCommand(Commands.OpenRovoDevMcpJson, async () => await openRovoDevConfigFile('mcp.json')),
         commands.registerCommand(
-            Commands.OpenRovoDevGlobalMemory,
+            RovodevCommands.OpenRovoDevConfig,
+            async () => await openRovoDevConfigFile('config.yml'),
+        ),
+        commands.registerCommand(
+            RovodevCommands.OpenRovoDevMcpJson,
+            async () => await openRovoDevConfigFile('mcp.json'),
+        ),
+        commands.registerCommand(
+            RovodevCommands.OpenRovoDevGlobalMemory,
             async () => await openRovoDevConfigFile('.agent.md'),
         ),
-        commands.registerCommand(Commands.OpenRovoDevLogFile, async () => await openRovoDevConfigFile('rovodev.log')),
+        commands.registerCommand(
+            RovodevCommands.OpenRovoDevLogFile,
+            async () => await openRovoDevConfigFile('rovodev.log'),
+        ),
     );
 }
 

src/constants.ts

@@ -83,19 +83,9 @@ export const enum Commands {
     DisableHelpExplorer = 'atlascode.disableHelpExplorer',
     CreateNewJql = 'atlascode.jira.createNewJql',
     ToDoIssue = 'atlascode.jira.todoIssue',
-    RovodevAsk = 'atlascode.rovodev.askRovoDev',
-    RovodevAskInteractive = 'atlascode.rovodev.askInteractive',
-    RovodevAddToContext = 'atlascode.rovodev.addToContext',
-    RovodevNewSession = 'atlascode.rovodev.newChatSession',
-    RovodevShowTerminal = 'atlascode.rovodev.showTerminal',
-    RovodevShareFeedback = 'atlascode.rovodev.shareFeedback',
     InProgressIssue = 'atlascode.jira.inProgressIssue',
     DoneIssue = 'atlascode.jira.doneIssue',
     ShowOnboardingFlow = 'atlascode.showOnboardingFlow',
-    OpenRovoDevConfig = 'atlascode.openRovoDevConfig',
-    OpenRovoDevMcpJson = 'atlascode.openRovoDevMcpJson',
-    OpenRovoDevGlobalMemory = 'atlascode.openRovoDevGlobalMemory',
-    OpenRovoDevLogFile = 'atlascode.openRovoDevLogFile',
     OpenNativeSettings = 'atlascode.openNativeSettings',
     QuickAuth = 'atlascode.rovodev.quickAuth',
     JiraLogin = 'atlascode.jira.login',

src/container.ts

@@ -34,6 +34,7 @@ import { Logger } from './logger';
 import OnboardingProvider from './onboarding/onboardingProvider';
 import { registerQuickAuthCommand } from './onboarding/quickFlow';
 import { Pipeline } from './pipelines/model';
+import { RovodevCommandContext } from './rovo-dev/api/componentApi';
 import { RovoDevCodeActionProvider } from './rovo-dev/rovoDevCodeActionProvider';
 import { RovoDevProcessManager } from './rovo-dev/rovoDevProcessManager';
 import { RovoDevWebviewProvider } from './rovo-dev/rovoDevWebviewProvider';
@@ -350,7 +351,7 @@ export class Container {
                 context.subscriptions.push(this._rovodevDisposable);
 
                 // this enables the Rovo Dev activity bar
-                await setCommandContext(CommandContext.RovoDevEnabled, true);
+                await setCommandContext(RovodevCommandContext.RovoDevEnabled, true);
 
                 // only in Boysenberry, we auto-focus the Rovo Dev view
                 if (this.isBoysenberryMode) {
@@ -397,7 +398,7 @@ export class Container {
             this._rovodevDisposable.dispose();
             this._rovodevDisposable = undefined;
 
-            await setCommandContext(CommandContext.RovoDevEnabled, false);
+            await setCommandContext(RovodevCommandContext.RovoDevEnabled, false);
             await RovoDevProcessManager.deactivateRovoDevProcessManager();
         } catch (error) {
             RovoDevLogger.error(error, 'Disabling Rovo Dev');

src/rovo-dev/api/componentApi.ts

@@ -0,0 +1,27 @@
+/**
+ * Commmands supported by the rovodev component
+ */
+export const RovodevCommands = {
+    RovodevAsk: 'atlascode.rovodev.askRovoDev',
+    RovodevAskInteractive: 'atlascode.rovodev.askInteractive',
+    RovodevAddToContext: 'atlascode.rovodev.addToContext',
+    RovodevNewSession: 'atlascode.rovodev.newChatSession',
+    RovodevShowTerminal: 'atlascode.rovodev.showTerminal',
+    RovodevShareFeedback: 'atlascode.rovodev.shareFeedback',
+    OpenRovoDevConfig: 'atlascode.openRovoDevConfig',
+    OpenRovoDevMcpJson: 'atlascode.openRovoDevMcpJson',
+    OpenRovoDevGlobalMemory: 'atlascode.openRovoDevGlobalMemory',
+    OpenRovoDevLogFile: 'atlascode.openRovoDevLogFile',
+} as const;
+
+/**
+ * Command context releavant to the rovodev component
+ */
+export const RovodevCommandContext = {
+    RovoDevEnabled: 'atlascode:rovoDevEnabled',
+    RovoDevTerminalEnabled: 'atlascode:rovoDevTerminalEnabled',
+} as const;
+
+// Type safety in case we need to refer to these elsewhere
+export type RovodevCommand = (typeof RovodevCommands)[keyof typeof RovodevCommands];
+export type RovodevCommandContextItem = (typeof RovodevCommandContext)[keyof typeof RovodevCommandContext];

src/rovo-dev/api/extensionApi.ts

@@ -1,7 +1,10 @@
 import { isMinimalIssue, MinimalIssue, readSearchResults } from '@atlassianlabs/jira-pi-common-models';
 import { ValidBasicAuthSiteData } from 'src/atlclients/clientManager';
+import { showIssueForURL } from 'src/commands/jira/showIssue';
+import { Commands } from 'src/constants';
 import { Container } from 'src/container';
 import { SearchJiraHelper } from 'src/views/jira/searchJiraHelper';
+import { commands, Uri } from 'vscode';
 
 import { AuthInfo, DetailedSiteInfo, ProductJira } from './extensionApiTypes';
 
@@ -13,6 +16,10 @@ export class JiraApi {
         return Container.siteManager.getSitesAvailable(ProductJira);
     };
 
+    public showIssue = async (issueURL: string): Promise<void> => {
+        await showIssueForURL(issueURL);
+    };
+
     public fetchWorkItems = async (site: DetailedSiteInfo): Promise<MinimalIssue<DetailedSiteInfo>[]> => {
         // Fetch from cache first
         let assignedIssuesForSite = this.fetchWorkItemsFromCache(site);
@@ -122,5 +129,27 @@ export class ExtensionApi {
         },
     };
 
+    commands = {
+        openFolder: async (): Promise<void> => {
+            await commands.executeCommand(Commands.WorkbenchOpenFolder);
+        },
+        focusRovodevView: async (): Promise<void> => {
+            await commands.executeCommand('atlascode.views.rovoDev.webView.focus');
+        },
+        showUserAuthentication: async ({ openApiTokenLogin }: { openApiTokenLogin: boolean }) => {
+            if (openApiTokenLogin) {
+                await commands.executeCommand(Commands.JiraAPITokenLogin);
+            } else {
+                await commands.executeCommand(Commands.ShowJiraAuth);
+            }
+        },
+        showDiff: async (args: { left: Uri; right: Uri; title: string }) => {
+            await commands.executeCommand('vscode.diff', args.left, args.right, args.title);
+        },
+        setCommandContext: async (key: string, value: any) => {
+            await commands.executeCommand('setContext', key, value);
+        },
+    };
+
     public readonly jira = new JiraApi();
 }

src/rovo-dev/rovoDevCodeActionProvider.ts

@@ -1,7 +1,7 @@
 import path from 'path';
-import { Commands } from 'src/constants';
 import * as vscode from 'vscode';
 
+import { RovodevCommands } from './api/componentApi';
 import { ExtensionApi } from './api/extensionApi';
 
 export class RovoDevCodeActionProvider implements vscode.CodeActionProvider {
@@ -35,7 +35,7 @@ export class RovoDevCodeActionProvider implements vscode.CodeActionProvider {
             {
                 title: 'Rovo Dev: Add to Context',
                 command: {
-                    command: Commands.RovodevAddToContext,
+                    command: RovodevCommands.RovodevAddToContext,
                     title: 'Add to Rovo Dev Context',
                 },
             },
@@ -58,7 +58,7 @@ export class RovoDevCodeActionProvider implements vscode.CodeActionProvider {
             : prompt;
 
         action.command = {
-            command: Commands.RovodevAsk,
+            command: RovodevCommands.RovodevAsk,
             title: 'Ask Rovo Dev',
             arguments: [
                 finalPrompt,

src/rovo-dev/rovoDevWebviewProvider.test.ts

@@ -50,6 +50,13 @@ jest.mock('./api/extensionApi', () => ({
             getSites: jest.fn(() => []),
             fetchWorkItems: jest.fn(() => Promise.resolve([])),
         },
+        commands: {
+            openFolder: jest.fn(),
+            focusRovodevView: jest.fn(),
+            showUserAuthentication: jest.fn(),
+            showDiff: jest.fn(),
+            setCommandContext: jest.fn(),
+        },
     })),
 }));
 
@@ -165,13 +172,6 @@ jest.mock('./util/waitFor', () => ({
     safeWaitFor: jest.fn(),
 }));
 
-jest.mock('../../src/commandContext', () => ({
-    setCommandContext: jest.fn(),
-    CommandContext: {
-        RovoDevTerminalEnabled: 'rovoDevTerminalEnabled',
-    },
-}));
-
 describe('RovoDevWebviewProvider - Real Implementation Tests', () => {
     let provider: RovoDevWebviewProvider;
     let mockContext: ExtensionContext;

src/rovo-dev/rovoDevWebviewProvider.ts

@@ -1,15 +1,12 @@
 import { MinimalIssue } from '@atlassianlabs/jira-pi-common-models';
 import * as fs from 'fs';
 import path from 'path';
-import { CommandContext, setCommandContext } from 'src/commandContext';
-import { showIssueForURL } from 'src/commands/jira/showIssue';
 import { configuration } from 'src/config/configuration';
 import { getFsPromise } from 'src/rovo-dev/util/fsPromises';
 import { safeWaitFor } from 'src/rovo-dev/util/waitFor';
 import { v4 } from 'uuid';
 import {
     CancellationToken,
-    commands,
     ConfigurationChangeEvent,
     Disposable,
     env,
@@ -26,9 +23,9 @@ import {
     workspace,
 } from 'vscode';
 
-import { Commands } from '../constants';
 import { GitErrorCodes } from '../typings/git';
 import { getHtmlForView } from '../webview/common/getHtmlForView';
+import { RovodevCommandContext } from './api/componentApi';
 import { DetailedSiteInfo, ExtensionApi } from './api/extensionApi';
 import { RovoDevApiClient, RovoDevHealthcheckResponse } from './client';
 import { RovoDevChatContextProvider } from './rovoDevChatContextProvider';
@@ -435,19 +432,17 @@ export class RovoDevWebviewProvider extends Disposable implements WebviewViewPro
                         break;
 
                     case RovoDevViewResponseType.LaunchJiraAuth:
-                        if (e.openApiTokenLogin) {
-                            await commands.executeCommand(Commands.JiraAPITokenLogin);
-                        } else {
-                            await commands.executeCommand(Commands.ShowJiraAuth);
-                        }
+                        await this.extensionApi.commands.showUserAuthentication({
+                            openApiTokenLogin: !!e.openApiTokenLogin,
+                        });
                         break;
 
                     case RovoDevViewResponseType.OpenFolder:
-                        await commands.executeCommand(Commands.WorkbenchOpenFolder);
+                        await this.extensionApi.commands.openFolder();
                         break;
 
                     case RovoDevViewResponseType.OpenJira:
-                        await showIssueForURL(e.url);
+                        await this.extensionApi.jira.showIssue(e.url);
                         break;
 
                     case RovoDevViewResponseType.McpConsentChoiceSubmit:
@@ -693,12 +688,11 @@ export class RovoDevWebviewProvider extends Disposable implements WebviewViewPro
         const resolvedPath = this.makeRelativePathAbsolute(filePath);
 
         if (cachedFilePath && fs.existsSync(cachedFilePath)) {
-            commands.executeCommand(
-                'vscode.diff',
-                Uri.file(cachedFilePath),
-                Uri.file(resolvedPath),
-                `${filePath} (Rovo Dev)`,
-            );
+            await this.extensionApi.commands.showDiff({
+                left: Uri.file(cachedFilePath),
+                right: Uri.file(resolvedPath),
+                title: `${filePath} (Rovo Dev)`,
+            });
             this._dwellTracker?.startDwellTimer();
         } else {
             let range: Range | undefined;
@@ -889,7 +883,7 @@ export class RovoDevWebviewProvider extends Disposable implements WebviewViewPro
 
     public async invokeRovoDevAskCommand(prompt: string, context?: RovoDevContextItem[]): Promise<void> {
         // Always focus on the specific vscode view, even if disabled (so user can see the login prompt)
-        commands.executeCommand('atlascode.views.rovoDev.webView.focus');
+        await this.extensionApi.commands.focusRovodevView();
 
         // Wait for the webview to initialize, up to 5 seconds
         const initialized = await safeWaitFor({
@@ -933,7 +927,7 @@ export class RovoDevWebviewProvider extends Disposable implements WebviewViewPro
      */
     public async setPromptTextWithFocus(text: string, contextItem?: RovoDevContextItem): Promise<void> {
         // Focus and wait for webview to be ready to receive messages
-        await commands.executeCommand('atlascode.views.rovoDev.webView.focus');
+        await this.extensionApi.commands.focusRovodevView();
 
         const webview = await safeWaitFor({
             condition: (value) => !!value,
@@ -1048,8 +1042,8 @@ export class RovoDevWebviewProvider extends Disposable implements WebviewViewPro
         this.refreshDebugPanel();
 
         // enable the 'show terminal' button only when in debugging
-        setCommandContext(
-            CommandContext.RovoDevTerminalEnabled,
+        this.extensionApi.commands.setCommandContext(
+            RovodevCommandContext.RovoDevTerminalEnabled,
             !this.isBoysenberry && this.extensionApi.metadata.isDebugging(),
         );