An AI-powered task-management system you can drop into Cursor, Lovable, Windsurf, Roo, and others.
JavaScript aicursorcursor-aicursorailovablelovable-devroocodetask-managertaskstasks-listwindsurfwindsurf-ai
feat: Add Cursor IDE custom slash commands support (#1215)
Joe Danziger0079b7defdad
diff --git a/.changeset/cursor-slash-commands.md b/.changeset/cursor-slash-commands.mdnew file mode 100644index 00000000..b4c74573--- /dev/null+++ b/.changeset/cursor-slash-commands.md@@ -0,0 +1,7 @@+---+"task-master-ai": minor+---++Add Cursor IDE custom slash command support++Expose Task Master commands as Cursor slash commands by copying assets/claude/commands to .cursor/commands on profile add and cleaning up on remove.diff --git a/src/profiles/cursor.js b/src/profiles/cursor.jsindex 8d9f7a91..29808c2d 100644--- a/src/profiles/cursor.js+++ b/src/profiles/cursor.js@@ -1,5 +1,134 @@// Cursor conversion profile for rule-transformer-import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';+import path from 'path';+import fs from 'fs';+import { log } from '../../scripts/modules/utils.js';+import { createProfile } from './base-profile.js';++// Helper copy; use cpSync when available, fallback to manual recursion+function copyRecursiveSync(src, dest) {+ if (fs.cpSync) {+ try {+ fs.cpSync(src, dest, { recursive: true, force: true });+ return;+ } catch (err) {+ throw new Error(`Failed to copy ${src} to ${dest}: ${err.message}`);+ }+ }+ const exists = fs.existsSync(src);+ let stats = null;+ let isDirectory = false;++ if (exists) {+ try {+ stats = fs.statSync(src);+ isDirectory = stats.isDirectory();+ } catch (err) {+ // Handle TOCTOU race condition - treat as non-existent/not-a-directory+ isDirectory = false;+ }+ }++ if (isDirectory) {+ try {+ if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });+ for (const child of fs.readdirSync(src)) {+ copyRecursiveSync(path.join(src, child), path.join(dest, child));+ }+ } catch (err) {+ throw new Error(+ `Failed to copy directory ${src} to ${dest}: ${err.message}`+ );+ }+ } else {+ try {+ // ensure parent exists for file copies+ fs.mkdirSync(path.dirname(dest), { recursive: true });+ fs.copyFileSync(src, dest);+ } catch (err) {+ throw new Error(`Failed to copy file ${src} to ${dest}: ${err.message}`);+ }+ }+}++// Helper function to recursively remove directory+function removeDirectoryRecursive(dirPath) {+ if (fs.existsSync(dirPath)) {+ try {+ fs.rmSync(dirPath, { recursive: true, force: true });+ return true;+ } catch (err) {+ log('error', `Failed to remove directory ${dirPath}: ${err.message}`);+ return false;+ }+ }+ return true;+}++// Resolve the Cursor profile directory from either project root, profile root, or rules dir+function resolveCursorProfileDir(baseDir) {+ const base = path.basename(baseDir);+ // If called with .../.cursor/rules -> return .../.cursor+ if (base === 'rules' && path.basename(path.dirname(baseDir)) === '.cursor') {+ return path.dirname(baseDir);+ }+ // If called with .../.cursor -> return as-is+ if (base === '.cursor') return baseDir;+ // Otherwise assume project root and append .cursor+ return path.join(baseDir, '.cursor');+}++// Lifecycle functions for Cursor profile+function onAddRulesProfile(targetDir, assetsDir) {+ // Copy commands directory recursively+ const commandsSourceDir = path.join(assetsDir, 'claude', 'commands');+ const profileDir = resolveCursorProfileDir(targetDir);+ const commandsDestDir = path.join(profileDir, 'commands');++ if (!fs.existsSync(commandsSourceDir)) {+ log(+ 'warn',+ `[Cursor] Source commands directory does not exist: ${commandsSourceDir}`+ );+ return;+ }++ try {+ // Ensure fresh state to avoid stale command files+ try {+ fs.rmSync(commandsDestDir, { recursive: true, force: true });+ log(+ 'debug',+ `[Cursor] Removed existing commands directory: ${commandsDestDir}`+ );+ } catch (deleteErr) {+ // Directory might not exist, which is fine+ log(+ 'debug',+ `[Cursor] Commands directory did not exist or could not be removed: ${deleteErr.message}`+ );+ }++ copyRecursiveSync(commandsSourceDir, commandsDestDir);+ log('debug', `[Cursor] Copied commands directory to ${commandsDestDir}`);+ } catch (err) {+ log(+ 'error',+ `[Cursor] An error occurred during commands copy: ${err.message}`+ );+ }+}++function onRemoveRulesProfile(targetDir) {+ // Remove .cursor/commands directory recursively+ const profileDir = resolveCursorProfileDir(targetDir);+ const commandsDir = path.join(profileDir, 'commands');+ if (removeDirectoryRecursive(commandsDir)) {+ log(+ 'debug',+ `[Cursor] Ensured commands directory removed at ${commandsDir}`+ );+ }+}// Create and export cursor profile using the base factoryexport const cursorProfile = createProfile({@@ -8,5 +137,10 @@ export const cursorProfile = createProfile({url: 'cursor.so',docsUrl: 'docs.cursor.com',targetExtension: '.mdc', // Cursor keeps .mdc extension- supportsRulesSubdirectories: true+ supportsRulesSubdirectories: true,+ onAdd: onAddRulesProfile,+ onRemove: onRemoveRulesProfile});++// Export lifecycle functions separately to avoid naming conflicts+export { onAddRulesProfile, onRemoveRulesProfile };diff --git a/src/utils/rule-transformer.js b/src/utils/rule-transformer.jsindex b1a6a818..39e69997 100644--- a/src/utils/rule-transformer.js+++ b/src/utils/rule-transformer.js@@ -210,7 +210,7 @@ export function convertAllRulesToProfileRules(projectRoot, profile) {if (typeof profile.onAddRulesProfile === 'function') {try {const assetsDir = getAssetsDir();- profile.onAddRulesProfile(projectRoot, assetsDir);+ profile.onAddRulesProfile(targetDir, assetsDir);log('debug',`[Rule Transformer] Called onAddRulesProfile for ${profile.profileName}`@@ -305,7 +305,7 @@ export function convertAllRulesToProfileRules(projectRoot, profile) {if (typeof profile.onPostConvertRulesProfile === 'function') {try {const assetsDir = getAssetsDir();- profile.onPostConvertRulesProfile(projectRoot, assetsDir);+ profile.onPostConvertRulesProfile(targetDir, assetsDir);log('debug',`[Rule Transformer] Called onPostConvertRulesProfile for ${profile.profileName}`@@ -347,7 +347,7 @@ export function removeProfileRules(projectRoot, profile) {// 1. Call onRemoveRulesProfile first (for custom cleanup like removing assets)if (typeof profile.onRemoveRulesProfile === 'function') {try {- profile.onRemoveRulesProfile(projectRoot);+ profile.onRemoveRulesProfile(targetDir);log('debug',`[Rule Transformer] Called onRemoveRulesProfile for ${profile.profileName}`diff --git a/tests/integration/profiles/cursor-init-functionality.test.js b/tests/integration/profiles/cursor-init-functionality.test.jsindex a07ea38f..b17239bf 100644--- a/tests/integration/profiles/cursor-init-functionality.test.js+++ b/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');+ });});diff --git a/tests/unit/profiles/cursor-integration.test.js b/tests/unit/profiles/cursor-integration.test.jsindex eb962184..6a7900a0 100644--- a/tests/unit/profiles/cursor-integration.test.js+++ b/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();+ });+ });});