feat: Add Cursor IDE custom slash commands support (#1215)

tests/integration/profiles/cursor-init-functionality.test.js

@@ -54,4 +54,33 @@ describe('Cursor Profile Initialization Functionality', () => {
 		);
 		expect(cursorProfile.conversionConfig.toolNames.search).toBe('search');
 	});
+
+	test('cursor.js has lifecycle functions for command copying', () => {
+		// Check that the source file contains our new lifecycle functions
+		expect(cursorProfileContent).toContain('function onAddRulesProfile');
+		expect(cursorProfileContent).toContain('function onRemoveRulesProfile');
+		expect(cursorProfileContent).toContain('copyRecursiveSync');
+		expect(cursorProfileContent).toContain('removeDirectoryRecursive');
+	});
+
+	test('cursor.js copies commands from claude/commands to .cursor/commands', () => {
+		// Check that the onAddRulesProfile function copies from the correct source
+		expect(cursorProfileContent).toContain(
+			"path.join(assetsDir, 'claude', 'commands')"
+		);
+		// Destination path is built via a resolver to handle both project root and rules dir
+		expect(cursorProfileContent).toContain('resolveCursorProfileDir(');
+		expect(cursorProfileContent).toMatch(
+			/path\.join\(\s*profileDir\s*,\s*['"]commands['"]\s*\)/
+		);
+		expect(cursorProfileContent).toContain(
+			'copyRecursiveSync(commandsSourceDir, commandsDestDir)'
+		);
+
+		// Check that lifecycle functions are properly registered with the profile
+		expect(cursorProfile.onAddRulesProfile).toBeDefined();
+		expect(cursorProfile.onRemoveRulesProfile).toBeDefined();
+		expect(typeof cursorProfile.onAddRulesProfile).toBe('function');
+		expect(typeof cursorProfile.onRemoveRulesProfile).toBe('function');
+	});
 });

tests/unit/profiles/cursor-integration.test.js

@@ -8,18 +8,37 @@ jest.mock('child_process', () => ({
 	execSync: jest.fn()
 }));
 
-// Mock console methods
-jest.mock('console', () => ({
+// Mock console methods to avoid chalk issues
+const mockLog = jest.fn();
+const originalConsole = global.console;
+const mockConsole = {
 	log: jest.fn(),
 	info: jest.fn(),
 	warn: jest.fn(),
 	error: jest.fn(),
 	clear: jest.fn()
+};
+global.console = mockConsole;
+
+// Mock utils logger to avoid chalk dependency issues
+await jest.unstable_mockModule('../../../scripts/modules/utils.js', () => ({
+	default: undefined,
+	log: mockLog,
+	isSilentMode: () => false
 }));
 
+// Import the cursor profile after mocking
+const { cursorProfile, onAddRulesProfile, onRemoveRulesProfile } = await import(
+	'../../../src/profiles/cursor.js'
+);
+
 describe('Cursor Integration', () => {
 	let tempDir;
 
+	afterAll(() => {
+		global.console = originalConsole;
+	});
+
 	beforeEach(() => {
 		jest.clearAllMocks();
 
@@ -75,4 +94,127 @@ describe('Cursor Integration', () => {
 			{ recursive: true }
 		);
 	});
+
+	test('cursor profile has lifecycle functions for command copying', () => {
+		// Assert that the profile exports the lifecycle functions
+		expect(typeof onAddRulesProfile).toBe('function');
+		expect(typeof onRemoveRulesProfile).toBe('function');
+		expect(cursorProfile.onAddRulesProfile).toBe(onAddRulesProfile);
+		expect(cursorProfile.onRemoveRulesProfile).toBe(onRemoveRulesProfile);
+	});
+
+	describe('command copying lifecycle', () => {
+		let mockAssetsDir;
+		let mockTargetDir;
+
+		beforeEach(() => {
+			mockAssetsDir = path.join(tempDir, 'assets');
+			mockTargetDir = path.join(tempDir, 'target');
+
+			// Reset all mocks
+			jest.clearAllMocks();
+
+			// Mock fs methods for the lifecycle functions
+			jest.spyOn(fs, 'existsSync').mockImplementation((filePath) => {
+				const pathStr = filePath.toString();
+				if (pathStr.includes('claude/commands')) {
+					return true; // Mock that source commands exist
+				}
+				return false;
+			});
+
+			jest.spyOn(fs, 'mkdirSync').mockImplementation(() => {});
+			jest.spyOn(fs, 'readdirSync').mockImplementation(() => ['tm']);
+			jest
+				.spyOn(fs, 'statSync')
+				.mockImplementation(() => ({ isDirectory: () => true }));
+			jest.spyOn(fs, 'copyFileSync').mockImplementation(() => {});
+			jest.spyOn(fs, 'rmSync').mockImplementation(() => {});
+		});
+
+		afterEach(() => {
+			jest.restoreAllMocks();
+		});
+
+		test('onAddRulesProfile copies commands from assets to .cursor/commands', () => {
+			// Detect if cpSync exists and set up appropriate spy
+			if (fs.cpSync) {
+				const cpSpy = jest.spyOn(fs, 'cpSync').mockImplementation(() => {});
+
+				// Act
+				onAddRulesProfile(mockTargetDir, mockAssetsDir);
+
+				// Assert
+				expect(fs.existsSync).toHaveBeenCalledWith(
+					path.join(mockAssetsDir, 'claude', 'commands')
+				);
+				expect(cpSpy).toHaveBeenCalledWith(
+					path.join(mockAssetsDir, 'claude', 'commands'),
+					path.join(mockTargetDir, '.cursor', 'commands'),
+					expect.objectContaining({ recursive: true, force: true })
+				);
+			} else {
+				// Act
+				onAddRulesProfile(mockTargetDir, mockAssetsDir);
+
+				// Assert
+				expect(fs.existsSync).toHaveBeenCalledWith(
+					path.join(mockAssetsDir, 'claude', 'commands')
+				);
+				expect(fs.mkdirSync).toHaveBeenCalledWith(
+					path.join(mockTargetDir, '.cursor', 'commands'),
+					{ recursive: true }
+				);
+				expect(fs.copyFileSync).toHaveBeenCalled();
+			}
+		});
+
+		test('onAddRulesProfile handles missing source directory gracefully', () => {
+			// Arrange - mock source directory not existing
+			jest.spyOn(fs, 'existsSync').mockImplementation(() => false);
+
+			// Act
+			onAddRulesProfile(mockTargetDir, mockAssetsDir);
+
+			// Assert - should not attempt to copy anything
+			expect(fs.mkdirSync).not.toHaveBeenCalled();
+			expect(fs.copyFileSync).not.toHaveBeenCalled();
+		});
+
+		test('onRemoveRulesProfile removes .cursor/commands directory', () => {
+			// Arrange - mock directory exists
+			jest.spyOn(fs, 'existsSync').mockImplementation(() => true);
+
+			// Act
+			onRemoveRulesProfile(mockTargetDir);
+
+			// Assert
+			expect(fs.rmSync).toHaveBeenCalledWith(
+				path.join(mockTargetDir, '.cursor', 'commands'),
+				{ recursive: true, force: true }
+			);
+		});
+
+		test('onRemoveRulesProfile handles missing directory gracefully', () => {
+			// Arrange - mock directory doesn't exist
+			jest.spyOn(fs, 'existsSync').mockImplementation(() => false);
+
+			// Act
+			onRemoveRulesProfile(mockTargetDir);
+
+			// Assert - should still return true but not attempt removal
+			expect(fs.rmSync).not.toHaveBeenCalled();
+		});
+
+		test('onRemoveRulesProfile handles removal errors gracefully', () => {
+			// Arrange - mock directory exists but removal fails
+			jest.spyOn(fs, 'existsSync').mockImplementation(() => true);
+			jest.spyOn(fs, 'rmSync').mockImplementation(() => {
+				throw new Error('Permission denied');
+			});
+
+			// Act & Assert - should not throw
+			expect(() => onRemoveRulesProfile(mockTargetDir)).not.toThrow();
+		});
+	});
 });