Handle bad slash commands as warnings (#1649)

* Handle unsupported slash commands with helpful warning instead of error

- Added special handling for InvalidPromptError with 'Unknown command:' messages
- Shows user-friendly warning dialog instead of scary error dialog with stack traces
- Made error type check case-insensitive for robustness
- Added tests for the new behavior
- Updated changelog

* Remove enable_deep_plan from test mocks after merge with main

* Revert package-lock.json changes

* Fix regex to specifically match slash commands with forward slash

---------

Co-authored-by: teg-atlassian <tzewdie@atlassian.com>

Author: Blastoplex

CHANGELOG.md

@@ -34,6 +34,7 @@
 
 - **RovoDev**: Fixed JSON parsing errors in ToolReturnMessage handling - added type checking before JSON.parse() to prevent "Input data should be a String" and invalid JSON errors
 - Added comprehensive test coverage for parseToolReturnMessage with both string and pre-parsed object inputs
+- Rovo Dev: Unsupported slash commands now show a helpful warning instead of an error dialog
 
 ## What's new in 4.0.22
 

src/rovo-dev/rovoDevChatProvider.test.ts

@@ -974,5 +974,74 @@ describe('RovoDevChatProvider', () => {
                 }),
             );
         });
+
+        it('should show warning instead of error for unsupported slash commands', async () => {
+            const mockPrompt: RovoDevPrompt = {
+                text: '/model',
+                context: [],
+            };
+
+            // Create a stream that returns an InvalidPromptError exception for unknown command
+            const mockReadableStream = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(
+                        new TextEncoder().encode(
+                            'event: exception\ndata: {"message":"Unknown command: /model","type":"InvalidPromptError"}\n\n',
+                        ),
+                    );
+                    controller.enqueue(new TextEncoder().encode('event: close\ndata: \n\n'));
+                    controller.close();
+                },
+            });
+            const mockResponse = { body: mockReadableStream } as Response;
+            mockApiClient.chat.mockResolvedValue(mockResponse);
+
+            await chatProvider.executeChat(mockPrompt, []);
+
+            // Should show warning dialog, not error
+            expect(mockWebview.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: RovoDevProviderMessageType.ShowDialog,
+                    message: expect.objectContaining({
+                        event_kind: '_RovoDevDialog',
+                        type: 'warning',
+                        title: 'Unsupported Command',
+                        text: 'The command /model is not supported.',
+                    }),
+                }),
+            );
+        });
+
+        it('should extract command name from InvalidPromptError message', async () => {
+            const mockPrompt: RovoDevPrompt = {
+                text: '/unknowncommand',
+                context: [],
+            };
+
+            const mockReadableStream = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(
+                        new TextEncoder().encode(
+                            'event: exception\ndata: {"message":"Unknown command: /unknowncommand","type":"InvalidPromptError"}\n\n',
+                        ),
+                    );
+                    controller.enqueue(new TextEncoder().encode('event: close\ndata: \n\n'));
+                    controller.close();
+                },
+            });
+            const mockResponse = { body: mockReadableStream } as Response;
+            mockApiClient.chat.mockResolvedValue(mockResponse);
+
+            await chatProvider.executeChat(mockPrompt, []);
+
+            expect(mockWebview.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: RovoDevProviderMessageType.ShowDialog,
+                    message: expect.objectContaining({
+                        text: 'The command /unknowncommand is not supported.',
+                    }),
+                }),
+            );
+        });
     });
 });

src/rovo-dev/rovoDevChatProvider.ts

@@ -549,6 +549,27 @@ export class RovoDevChatProvider {
                 break;
 
             case 'exception': {
+                // Handle InvalidPromptError for unsupported slash commands as a warning instead of an error
+                if (
+                    response.type.toLowerCase().includes('invalidprompt') &&
+                    response.message.includes('Unknown command:')
+                ) {
+                    // Extract the command name from the message (e.g., "Unknown command: /model" -> "/model")
+                    const commandMatch = response.message.match(/Unknown command:\s*(\/\S+)/);
+                    const command = commandMatch ? commandMatch[1] : 'the command you entered';
+
+                    await webview.postMessage({
+                        type: RovoDevProviderMessageType.ShowDialog,
+                        message: {
+                            event_kind: '_RovoDevDialog',
+                            type: 'warning',
+                            title: 'Unsupported Command',
+                            text: `The command ${command} is not supported.`,
+                        },
+                    });
+                    break;
+                }
+
                 RovoDevTelemetryProvider.logError(
                     new Error(`${response.type} ${response.message}`),
                     response.title || undefined,