fix comment on pr

package.json

@@ -105,17 +105,17 @@
 			{
 				"command": "roo-cline.explainCode",
 				"title": "Explain Code",
-		    "category": "Roo Cline"
+				"category": "Roo Code"
 			},
 			{
 				"command": "roo-cline.fixCode",
 				"title": "Fix Code",
-		    "category": "Roo Cline"
+				"category": "Roo Code"
 			},
 			{
 				"command": "roo-cline.improveCode",
 				"title": "Improve Code",
-		    "category": "Roo Cline"
+				"category": "Roo Code"
 			}
 		],
 		"menus": {
@@ -123,17 +123,17 @@
 				{
 					"command": "roo-cline.explainCode",
 					"when": "editorHasSelection",
-		      "group": "Roo Cline@1"
+					"group": "Roo Code@1"
 				},
 				{
 					"command": "roo-cline.fixCode",
 					"when": "editorHasSelection",
-		      "group": "Roo Cline@2"
+					"group": "Roo Code@2"
 				},
 				{
 					"command": "roo-cline.improveCode",
 					"when": "editorHasSelection",
-		      "group": "Roo Cline@3"
+					"group": "Roo Code@3"
 				}
 			],
 			"view/title": [

src/core/CodeActionProvider.ts

@@ -1,97 +1,99 @@
-import * as vscode from 'vscode';
+import * as vscode from "vscode"
-import * as path from 'path';
+import * as path from "path"
 
 export const ACTION_NAMES = {
-    EXPLAIN: 'Roo Cline: Explain Code',
+	EXPLAIN: "Roo Code: Explain Code",
-    FIX: 'Roo Cline: Fix Code',
+	FIX: "Roo Code: Fix Code",
-    IMPROVE: 'Roo Cline: Improve Code'
+	IMPROVE: "Roo Code: Improve Code",
-} as const;
+} as const
 
 const COMMAND_IDS = {
-    EXPLAIN: 'roo-cline.explainCode',
+	EXPLAIN: "roo-cline.explainCode",
-    FIX: 'roo-cline.fixCode',
+	FIX: "roo-cline.fixCode",
-    IMPROVE: 'roo-cline.improveCode'
+	IMPROVE: "roo-cline.improveCode",
-} as const;
+} as const
 
 interface DiagnosticData {
-    message: string;
+	message: string
-    severity: vscode.DiagnosticSeverity;
+	severity: vscode.DiagnosticSeverity
-    code?: string | number | { value: string | number; target: vscode.Uri };
+	code?: string | number | { value: string | number; target: vscode.Uri }
-    source?: string;
+	source?: string
-    range: vscode.Range;
+	range: vscode.Range
 }
 
 interface EffectiveRange {
-    range: vscode.Range;
+	range: vscode.Range
-    text: string;
+	text: string
 }
 
 export class CodeActionProvider implements vscode.CodeActionProvider {
 	public static readonly providedCodeActionKinds = [
 		vscode.CodeActionKind.QuickFix,
 		vscode.CodeActionKind.RefactorRewrite,
-    ];
+	]
 
 	// Cache file paths for performance
-    private readonly filePathCache = new WeakMap<vscode.TextDocument, string>();
+	private readonly filePathCache = new WeakMap<vscode.TextDocument, string>()
 
 	private getEffectiveRange(
 		document: vscode.TextDocument,
-        range: vscode.Range | vscode.Selection
+		range: vscode.Range | vscode.Selection,
 	): EffectiveRange | null {
 		try {
-            const selectedText = document.getText(range);
+			const selectedText = document.getText(range)
 			if (selectedText) {
-                return { range, text: selectedText };
+				return { range, text: selectedText }
 			}
 
-            const currentLine = document.lineAt(range.start.line);
+			const currentLine = document.lineAt(range.start.line)
 			if (!currentLine.text.trim()) {
-                return null;
+				return null
 			}
 
 			// Optimize range creation by checking bounds first
-            const startLine = Math.max(0, currentLine.lineNumber - 1);
+			const startLine = Math.max(0, currentLine.lineNumber - 1)
-            const endLine = Math.min(document.lineCount - 1, currentLine.lineNumber + 1);
+			const endLine = Math.min(document.lineCount - 1, currentLine.lineNumber + 1)
 
 			// Only create new positions if needed
 			const effectiveRange = new vscode.Range(
 				startLine === currentLine.lineNumber ? range.start : new vscode.Position(startLine, 0),
-                endLine === currentLine.lineNumber ? range.end : new vscode.Position(endLine, document.lineAt(endLine).text.length)
+				endLine === currentLine.lineNumber
-            );
+					? range.end
+					: new vscode.Position(endLine, document.lineAt(endLine).text.length),
+			)
 
 			return {
 				range: effectiveRange,
-                text: document.getText(effectiveRange)
+				text: document.getText(effectiveRange),
-            };
+			}
 		} catch (error) {
-            console.error('Error getting effective range:', error);
+			console.error("Error getting effective range:", error)
-            return null;
+			return null
 		}
 	}
 
 	private getFilePath(document: vscode.TextDocument): string {
 		// Check cache first
-        let filePath = this.filePathCache.get(document);
+		let filePath = this.filePathCache.get(document)
 		if (filePath) {
-            return filePath;
+			return filePath
 		}
 
 		try {
-            const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);
+			const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri)
 			if (!workspaceFolder) {
-                filePath = document.uri.fsPath;
+				filePath = document.uri.fsPath
 			} else {
-                const relativePath = path.relative(workspaceFolder.uri.fsPath, document.uri.fsPath);
+				const relativePath = path.relative(workspaceFolder.uri.fsPath, document.uri.fsPath)
-                filePath = (!relativePath || relativePath.startsWith('..')) ? document.uri.fsPath : relativePath;
+				filePath = !relativePath || relativePath.startsWith("..") ? document.uri.fsPath : relativePath
 			}
 
 			// Cache the result
-            this.filePathCache.set(document, filePath);
+			this.filePathCache.set(document, filePath)
-            return filePath;
+			return filePath
 		} catch (error) {
-            console.error('Error getting file path:', error);
+			console.error("Error getting file path:", error)
-            return document.uri.fsPath;
+			return document.uri.fsPath
 		}
 	}
 
@@ -101,19 +103,14 @@ export class CodeActionProvider implements vscode.CodeActionProvider {
 			severity: diagnostic.severity,
 			code: diagnostic.code,
 			source: diagnostic.source,
-            range: diagnostic.range // Reuse the range object
+			range: diagnostic.range, // Reuse the range object
-        };
+		}
 	}
 
-    private createAction(
+	private createAction(title: string, kind: vscode.CodeActionKind, command: string, args: any[]): vscode.CodeAction {
-        title: string,
+		const action = new vscode.CodeAction(title, kind)
-        kind: vscode.CodeActionKind,
+		action.command = { command, title, arguments: args }
-        command: string,
+		return action
-        args: any[]
-    ): vscode.CodeAction {
-        const action = new vscode.CodeAction(title, kind);
-        action.command = { command, title, arguments: args };
-        return action;
 	}
 
 	private hasIntersectingRange(range1: vscode.Range, range2: vscode.Range): boolean {
@@ -123,59 +120,60 @@ export class CodeActionProvider implements vscode.CodeActionProvider {
 			range2.start.line > range1.end.line ||
 			(range2.end.line === range1.start.line && range2.end.character < range1.start.character) ||
 			(range2.start.line === range1.end.line && range2.start.character > range1.end.character)
-        );
+		)
 	}
 
 	public provideCodeActions(
 		document: vscode.TextDocument,
 		range: vscode.Range | vscode.Selection,
-        context: vscode.CodeActionContext
+		context: vscode.CodeActionContext,
 	): vscode.ProviderResult<(vscode.CodeAction | vscode.Command)[]> {
 		try {
-            const effectiveRange = this.getEffectiveRange(document, range);
+			const effectiveRange = this.getEffectiveRange(document, range)
 			if (!effectiveRange) {
-                return [];
+				return []
 			}
 
-            const filePath = this.getFilePath(document);
+			const filePath = this.getFilePath(document)
-            const actions: vscode.CodeAction[] = [];
+			const actions: vscode.CodeAction[] = []
 
 			// Create actions using helper method
-            actions.push(this.createAction(
+			actions.push(
-                ACTION_NAMES.EXPLAIN,
+				this.createAction(ACTION_NAMES.EXPLAIN, vscode.CodeActionKind.QuickFix, COMMAND_IDS.EXPLAIN, [
-                vscode.CodeActionKind.QuickFix,
+					filePath,
-                COMMAND_IDS.EXPLAIN,
+					effectiveRange.text,
-                [filePath, effectiveRange.text]
+				]),
-            ));
+			)
 
 			// Only process diagnostics if they exist
 			if (context.diagnostics.length > 0) {
-                const relevantDiagnostics = context.diagnostics.filter(d =>
+				const relevantDiagnostics = context.diagnostics.filter((d) =>
-                    this.hasIntersectingRange(effectiveRange.range, d.range)
+					this.hasIntersectingRange(effectiveRange.range, d.range),
-                );
+				)
 
 				if (relevantDiagnostics.length > 0) {
-                    const diagnosticMessages = relevantDiagnostics.map(this.createDiagnosticData);
+					const diagnosticMessages = relevantDiagnostics.map(this.createDiagnosticData)
-                    actions.push(this.createAction(
+					actions.push(
-                        ACTION_NAMES.FIX,
+						this.createAction(ACTION_NAMES.FIX, vscode.CodeActionKind.QuickFix, COMMAND_IDS.FIX, [
-                        vscode.CodeActionKind.QuickFix,
+							filePath,
-                        COMMAND_IDS.FIX,
+							effectiveRange.text,
-                        [filePath, effectiveRange.text, diagnosticMessages]
+							diagnosticMessages,
-                    ));
+						]),
+					)
 				}
 			}
 
-            actions.push(this.createAction(
+			actions.push(
-                ACTION_NAMES.IMPROVE,
+				this.createAction(ACTION_NAMES.IMPROVE, vscode.CodeActionKind.RefactorRewrite, COMMAND_IDS.IMPROVE, [
-                vscode.CodeActionKind.RefactorRewrite,
+					filePath,
-                COMMAND_IDS.IMPROVE,
+					effectiveRange.text,
-                [filePath, effectiveRange.text]
+				]),
-            ));
+			)
 
-            return actions;
+			return actions
 		} catch (error) {
-            console.error('Error providing code actions:', error);
+			console.error("Error providing code actions:", error)
-            return [];
+			return []
 		}
 	}
 }

src/core/__tests__/CodeActionProvider.test.ts

@@ -1,145 +1,147 @@
-import * as vscode from 'vscode';
+import * as vscode from "vscode"
-import { CodeActionProvider } from '../CodeActionProvider';
+import { CodeActionProvider } from "../CodeActionProvider"
 
 // Mock VSCode API
-jest.mock('vscode', () => ({
+jest.mock("vscode", () => ({
 	CodeAction: jest.fn().mockImplementation((title, kind) => ({
 		title,
 		kind,
-        command: undefined
+		command: undefined,
 	})),
 	CodeActionKind: {
-        QuickFix: { value: 'quickfix' },
+		QuickFix: { value: "quickfix" },
-        RefactorRewrite: { value: 'refactor.rewrite' }
+		RefactorRewrite: { value: "refactor.rewrite" },
 	},
 	Range: jest.fn().mockImplementation((startLine, startChar, endLine, endChar) => ({
 		start: { line: startLine, character: startChar },
-        end: { line: endLine, character: endChar }
+		end: { line: endLine, character: endChar },
 	})),
 	Position: jest.fn().mockImplementation((line, character) => ({
 		line,
-        character
+		character,
 	})),
 	workspace: {
-        getWorkspaceFolder: jest.fn()
+		getWorkspaceFolder: jest.fn(),
 	},
 	DiagnosticSeverity: {
 		Error: 0,
 		Warning: 1,
 		Information: 2,
-        Hint: 3
+		Hint: 3,
-    }
+	},
-}));
+}))
 
-describe('CodeActionProvider', () => {
+describe("CodeActionProvider", () => {
-    let provider: CodeActionProvider;
+	let provider: CodeActionProvider
-    let mockDocument: any;
+	let mockDocument: any
-    let mockRange: any;
+	let mockRange: any
-    let mockContext: any;
+	let mockContext: any
 
 	beforeEach(() => {
-        provider = new CodeActionProvider();
+		provider = new CodeActionProvider()
 
 		// Mock document
 		mockDocument = {
 			getText: jest.fn(),
 			lineAt: jest.fn(),
 			lineCount: 10,
-            uri: { fsPath: '/test/file.ts' }
+			uri: { fsPath: "/test/file.ts" },
-        };
+		}
 
 		// Mock range
-        mockRange = new vscode.Range(0, 0, 0, 10);
+		mockRange = new vscode.Range(0, 0, 0, 10)
 
 		// Mock context
 		mockContext = {
-            diagnostics: []
+			diagnostics: [],
-        };
+		}
-    });
+	})
 
-    describe('getEffectiveRange', () => {
+	describe("getEffectiveRange", () => {
-        it('should return selected text when available', () => {
+		it("should return selected text when available", () => {
-            mockDocument.getText.mockReturnValue('selected text');
+			mockDocument.getText.mockReturnValue("selected text")
 
-            const result = (provider as any).getEffectiveRange(mockDocument, mockRange);
+			const result = (provider as any).getEffectiveRange(mockDocument, mockRange)
 
 			expect(result).toEqual({
 				range: mockRange,
-                text: 'selected text'
+				text: "selected text",
-            });
+			})
-        });
+		})
 
-        it('should return null for empty line', () => {
+		it("should return null for empty line", () => {
-            mockDocument.getText.mockReturnValue('');
+			mockDocument.getText.mockReturnValue("")
-            mockDocument.lineAt.mockReturnValue({ text: '', lineNumber: 0 });
+			mockDocument.lineAt.mockReturnValue({ text: "", lineNumber: 0 })
 
-            const result = (provider as any).getEffectiveRange(mockDocument, mockRange);
+			const result = (provider as any).getEffectiveRange(mockDocument, mockRange)
 
-            expect(result).toBeNull();
+			expect(result).toBeNull()
-        });
+		})
-    });
+	})
 
-    describe('getFilePath', () => {
+	describe("getFilePath", () => {
-        it('should return relative path when in workspace', () => {
+		it("should return relative path when in workspace", () => {
 			const mockWorkspaceFolder = {
-                uri: { fsPath: '/test' }
+				uri: { fsPath: "/test" },
-            };
+			}
-            (vscode.workspace.getWorkspaceFolder as jest.Mock).mockReturnValue(mockWorkspaceFolder);
+			;(vscode.workspace.getWorkspaceFolder as jest.Mock).mockReturnValue(mockWorkspaceFolder)
 
-            const result = (provider as any).getFilePath(mockDocument);
+			const result = (provider as any).getFilePath(mockDocument)
 
-            expect(result).toBe('file.ts');
+			expect(result).toBe("file.ts")
-        });
+		})
 
-        it('should return absolute path when not in workspace', () => {
+		it("should return absolute path when not in workspace", () => {
-            (vscode.workspace.getWorkspaceFolder as jest.Mock).mockReturnValue(null);
+			;(vscode.workspace.getWorkspaceFolder as jest.Mock).mockReturnValue(null)
 
-            const result = (provider as any).getFilePath(mockDocument);
+			const result = (provider as any).getFilePath(mockDocument)
 
-            expect(result).toBe('/test/file.ts');
+			expect(result).toBe("/test/file.ts")
-        });
+		})
-    });
+	})
 
-    describe('provideCodeActions', () => {
+	describe("provideCodeActions", () => {
 		beforeEach(() => {
-            mockDocument.getText.mockReturnValue('test code');
+			mockDocument.getText.mockReturnValue("test code")
-            mockDocument.lineAt.mockReturnValue({ text: 'test code', lineNumber: 0 });
+			mockDocument.lineAt.mockReturnValue({ text: "test code", lineNumber: 0 })
-        });
+		})
 
-        it('should provide explain and improve actions by default', () => {
+		it("should provide explain and improve actions by default", () => {
-            const actions = provider.provideCodeActions(mockDocument, mockRange, mockContext);
+			const actions = provider.provideCodeActions(mockDocument, mockRange, mockContext)
 
-            expect(actions).toHaveLength(2);
+			expect(actions).toHaveLength(2)
-            expect((actions as any)[0].title).toBe('Roo Cline: Explain Code');
+			expect((actions as any)[0].title).toBe("Roo Code: Explain Code")
-            expect((actions as any)[1].title).toBe('Roo Cline: Improve Code');
+			expect((actions as any)[1].title).toBe("Roo Code: Improve Code")
-        });
+		})
 
-        it('should provide fix action when diagnostics exist', () => {
+		it("should provide fix action when diagnostics exist", () => {
-            mockContext.diagnostics = [{
+			mockContext.diagnostics = [
-                message: 'test error',
+				{
+					message: "test error",
 					severity: vscode.DiagnosticSeverity.Error,
-                range: mockRange
+					range: mockRange,
-            }];
+				},
+			]
 
-            const actions = provider.provideCodeActions(mockDocument, mockRange, mockContext);
+			const actions = provider.provideCodeActions(mockDocument, mockRange, mockContext)
 
-            expect(actions).toHaveLength(3);
+			expect(actions).toHaveLength(3)
-            expect((actions as any).some((a: any) => a.title === 'Roo Cline: Fix Code')).toBe(true);
+			expect((actions as any).some((a: any) => a.title === "Roo Code: Fix Code")).toBe(true)
-        });
+		})
 
-        it('should handle errors gracefully', () => {
+		it("should handle errors gracefully", () => {
-            const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+			const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {})
 			mockDocument.getText.mockImplementation(() => {
-                throw new Error('Test error');
+				throw new Error("Test error")
-            });
+			})
-            mockDocument.lineAt.mockReturnValue({ text: 'test', lineNumber: 0 });
+			mockDocument.lineAt.mockReturnValue({ text: "test", lineNumber: 0 })
 
-            const actions = provider.provideCodeActions(mockDocument, mockRange, mockContext);
+			const actions = provider.provideCodeActions(mockDocument, mockRange, mockContext)
 
-            expect(actions).toEqual([]);
+			expect(actions).toEqual([])
-            expect(consoleErrorSpy).toHaveBeenCalledWith('Error getting effective range:', expect.any(Error));
+			expect(consoleErrorSpy).toHaveBeenCalledWith("Error getting effective range:", expect.any(Error))
 
-            consoleErrorSpy.mockRestore();
+			consoleErrorSpy.mockRestore()
-        });
+		})
-    });
+	})
-});
+})

src/extension.ts

@@ -201,7 +201,7 @@ export function activate(context: vscode.ExtensionContext) {
 		context,
 		"roo-cline.explainCode",
 		"EXPLAIN",
-		"Any specific questions about this code?",
+		"What would you like Roo to explain?",
 		"E.g. How does the error handling work?",
 	)
 
@@ -209,7 +209,7 @@ export function activate(context: vscode.ExtensionContext) {
 		context,
 		"roo-cline.fixCode",
 		"FIX",
-		"Any specific concerns about fixing this code?",
+		"What would you like Roo to fix?",
 		"E.g. Maintain backward compatibility",
 	)
 
@@ -217,7 +217,7 @@ export function activate(context: vscode.ExtensionContext) {
 		context,
 		"roo-cline.improveCode",
 		"IMPROVE",
-		"Any specific aspects you want to improve?",
+		"What would you like Roo to improve?",
 		"E.g. Focus on performance optimization",
 	)
 

src/test/extension.test.ts

@@ -8,8 +8,8 @@ const dotenv = require("dotenv")
 const testEnvPath = path.join(__dirname, ".test_env")
 dotenv.config({ path: testEnvPath })
 
-suite("Roo Cline Extension Test Suite", () => {
+suite("Roo Code Extension Test Suite", () => {
-	vscode.window.showInformationMessage("Starting Roo Cline extension tests.")
+	vscode.window.showInformationMessage("Starting Roo Code extension tests.")
 
 	test("Extension should be present", () => {
 		const extension = vscode.extensions.getExtension("RooVeterinaryInc.roo-cline")
@@ -117,16 +117,16 @@ suite("Roo Cline Extension Test Suite", () => {
 
 		// Test core commands are registered
 		const expectedCommands = [
-			'roo-cline.plusButtonClicked',
+			"roo-cline.plusButtonClicked",
-			'roo-cline.mcpButtonClicked',
+			"roo-cline.mcpButtonClicked",
-			'roo-cline.historyButtonClicked',
+			"roo-cline.historyButtonClicked",
-			'roo-cline.popoutButtonClicked',
+			"roo-cline.popoutButtonClicked",
-			'roo-cline.settingsButtonClicked',
+			"roo-cline.settingsButtonClicked",
-			'roo-cline.openInNewTab',
+			"roo-cline.openInNewTab",
-			'roo-cline.explainCode',
+			"roo-cline.explainCode",
-			'roo-cline.fixCode',
+			"roo-cline.fixCode",
-			'roo-cline.improveCode'
+			"roo-cline.improveCode",
-		];
+		]
 
 		for (const cmd of expectedCommands) {
 			assert.strictEqual(commands.includes(cmd), true, `Command ${cmd} should be registered`)
@@ -136,7 +136,7 @@ suite("Roo Cline Extension Test Suite", () => {
 	test("Views should be registered", () => {
 		const view = vscode.window.createWebviewPanel(
 			"roo-cline.SidebarProvider",
-			"Roo Cline",
+			"Roo Code",
 			vscode.ViewColumn.One,
 			{},
 		)
@@ -184,17 +184,12 @@ suite("Roo Cline Extension Test Suite", () => {
 
 		// Create webview panel with development options
 		const extensionUri = extension.extensionUri
-		const panel = vscode.window.createWebviewPanel(
+		const panel = vscode.window.createWebviewPanel("roo-cline.SidebarProvider", "Roo Code", vscode.ViewColumn.One, {
-			"roo-cline.SidebarProvider",
-			"Roo Cline",
-			vscode.ViewColumn.One,
-			{
 			enableScripts: true,
 			enableCommandUris: true,
 			retainContextWhenHidden: true,
 			localResourceRoots: [extensionUri],
-			},
+		})
-		)
 
 		try {
 			// Initialize webview with development context