ros/claude-task-master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

move profiles to /src

Browse Source
This commit is contained in:
Joe Danziger
2025-06-05 10:17:30 -04:00
parent 8f93a695e9
commit 948203ed7f
27 changed files with 26 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

249
scripts/profiles/base-profile.js
View File

@@ -1,249 +0,0 @@
// Base profile factory for rule-transformer
import path from 'path';
/**
* Creates a standardized profile configuration for different editors
* @param {Object} editorConfig - Editor-specific configuration
* @param {string} editorConfig.name - Profile name (e.g., 'cursor', 'vscode')
* @param {string} [editorConfig.displayName] - Display name for the editor (defaults to name)
* @param {string} editorConfig.url - Editor website URL
* @param {string} editorConfig.docsUrl - Editor documentation URL
* @param {string} editorConfig.profileDir - Directory for profile configuration
* @param {string} [editorConfig.rulesDir] - Directory for rules files (defaults to profileDir/rules)
* @param {boolean} [editorConfig.mcpConfig=true] - Whether to create MCP configuration
* @param {string} [editorConfig.mcpConfigName='mcp.json'] - Name of MCP config file
* @param {string} [editorConfig.fileExtension='.mdc'] - Source file extension
* @param {string} [editorConfig.targetExtension='.md'] - Target file extension
* @param {Object} [editorConfig.toolMappings={}] - Tool name mappings
* @param {Array} [editorConfig.customReplacements=[]] - Custom text replacements
* @param {Object} [editorConfig.customFileMap={}] - Custom file name mappings
* @param {boolean} [editorConfig.supportsRulesSubdirectories=false] - Whether to use taskmaster/ subdirectory for taskmaster-specific rules (only Cursor uses this by default)
* @param {Function} [editorConfig.onAdd] - Lifecycle hook for profile addition
* @param {Function} [editorConfig.onRemove] - Lifecycle hook for profile removal
* @param {Function} [editorConfig.onPostConvert] - Lifecycle hook for post-conversion
* @returns {Object} - Complete profile configuration
*/
export function createProfile(editorConfig) {
const {
name,
displayName = name,
url,
docsUrl,
profileDir,
rulesDir = `${profileDir}/rules`,
mcpConfig = true,
mcpConfigName = 'mcp.json',
fileExtension = '.mdc',
targetExtension = '.md',
toolMappings = {},
customReplacements = [],
customFileMap = {},
supportsRulesSubdirectories = false,
onAdd,
onRemove,
onPostConvert
} = editorConfig;
const mcpConfigPath = `${profileDir}/${mcpConfigName}`;
// Standard file mapping with custom overrides
// Use taskmaster subdirectory only if profile supports it
const taskmasterPrefix = supportsRulesSubdirectories ? 'taskmaster/' : '';
const defaultFileMap = {
'cursor_rules.mdc': `${name.toLowerCase()}_rules${targetExtension}`,
'dev_workflow.mdc': `${taskmasterPrefix}dev_workflow${targetExtension}`,
'self_improve.mdc': `self_improve${targetExtension}`,
'taskmaster.mdc': `${taskmasterPrefix}taskmaster${targetExtension}`
};
const fileMap = { ...defaultFileMap, ...customFileMap };
// Base global replacements that work for all editors
const baseGlobalReplacements = [
// Handle URLs in any context
{ from: /cursor\.so/gi, to: url },
{ from: /cursor\s*\.\s*so/gi, to: url },
{ from: /https?:\/\/cursor\.so/gi, to: `https://${url}` },
{ from: /https?:\/\/www\.cursor\.so/gi, to: `https://www.${url}` },
// Handle tool references
{ from: /\bedit_file\b/gi, to: toolMappings.edit_file || 'edit_file' },
{
from: /\bsearch tool\b/gi,
to: `${toolMappings.search || 'search'} tool`
},
{ from: /\bSearch Tool\b/g, to: `${toolMappings.search || 'Search'} Tool` },
// Handle basic terms with proper case handling
{
from: /\bcursor\b/gi,
to: (match) =>
match.charAt(0) === 'C' ? displayName : name.toLowerCase()
},
{ from: /Cursor/g, to: displayName },
{ from: /CURSOR/g, to: displayName.toUpperCase() },
// Handle file extensions if different
...(targetExtension !== fileExtension
? [
{
from: new RegExp(`\\${fileExtension}(?!\\])\\b`, 'g'),
to: targetExtension
}
]
: []),
// Handle documentation URLs
{ from: /docs\.cursor\.com/gi, to: docsUrl },
// Custom editor-specific replacements
...customReplacements
];
// Standard tool mappings
const defaultToolMappings = {
search: 'search',
read_file: 'read_file',
edit_file: 'edit_file',
create_file: 'create_file',
run_command: 'run_command',
terminal_command: 'terminal_command',
use_mcp: 'use_mcp',
switch_mode: 'switch_mode',
...toolMappings
};
// Create conversion config
const conversionConfig = {
// Profile name replacements
profileTerms: [
{ from: /cursor\.so/g, to: url },
{ from: /\[cursor\.so\]/g, to: `[${url}]` },
{ from: /href="https:\/\/cursor\.so/g, to: `href="https://${url}` },
{ from: /\(https:\/\/cursor\.so/g, to: `(https://${url}` },
{
from: /\bcursor\b/gi,
to: (match) => (match === 'Cursor' ? displayName : name.toLowerCase())
},
{ from: /Cursor/g, to: displayName }
],
// File extension replacements
fileExtensions:
targetExtension !== fileExtension
? [
{
from: new RegExp(`\\${fileExtension}\\b`, 'g'),
to: targetExtension
}
]
: [],
// Documentation URL replacements
docUrls: [
{
from: new RegExp(`https:\\/\\/docs\\.cursor\\.com\\/[^\\s)'\"]+`, 'g'),
to: (match) => match.replace('docs.cursor.com', docsUrl)
},
{
from: new RegExp(`https:\\/\\/${docsUrl}\\/`, 'g'),
to: `https://${docsUrl}/`
}
],
// Tool references - direct replacements
toolNames: defaultToolMappings,
// Tool references in context - more specific replacements
toolContexts: Object.entries(defaultToolMappings).flatMap(
([original, mapped]) => [
{
from: new RegExp(`\\b${original} tool\\b`, 'g'),
to: `${mapped} tool`
},
{ from: new RegExp(`\\bthe ${original}\\b`, 'g'), to: `the ${mapped}` },
{ from: new RegExp(`\\bThe ${original}\\b`, 'g'), to: `The ${mapped}` },
{
from: new RegExp(`\\bCursor ${original}\\b`, 'g'),
to: `${displayName} ${mapped}`
}
]
),
// Tool group and category names
toolGroups: [
{ from: /\bSearch tools\b/g, to: 'Read Group tools' },
{ from: /\bEdit tools\b/g, to: 'Edit Group tools' },
{ from: /\bRun tools\b/g, to: 'Command Group tools' },
{ from: /\bMCP servers\b/g, to: 'MCP Group tools' },
{ from: /\bSearch Group\b/g, to: 'Read Group' },
{ from: /\bEdit Group\b/g, to: 'Edit Group' },
{ from: /\bRun Group\b/g, to: 'Command Group' }
],
// File references in markdown links
fileReferences: {
pathPattern: /\[(.+?)\]\(mdc:\.cursor\/rules\/(.+?)\.mdc\)/g,
replacement: (match, text, filePath) => {
const baseName = path.basename(filePath, '.mdc');
const newFileName =
fileMap[`${baseName}.mdc`] || `${baseName}${targetExtension}`;
// Update the link text to match the new filename (strip directory path for display)
const newLinkText = path.basename(newFileName);
// For Cursor, keep the mdc: protocol; for others, use standard relative paths
if (name.toLowerCase() === 'cursor') {
return `[${newLinkText}](mdc:${rulesDir}/${newFileName})`;
} else {
return `[${newLinkText}](${rulesDir}/${newFileName})`;
}
}
}
};
function getTargetRuleFilename(sourceFilename) {
if (fileMap[sourceFilename]) {
return fileMap[sourceFilename];
}
return targetExtension !== fileExtension
? sourceFilename.replace(
new RegExp(`\\${fileExtension}$`),
targetExtension
)
: sourceFilename;
}
return {
profileName: name, // Use name for programmatic access (tests expect this)
displayName: displayName, // Keep displayName for UI purposes
profileDir,
rulesDir,
mcpConfig,
mcpConfigName,
mcpConfigPath,
supportsRulesSubdirectories,
fileMap,
globalReplacements: baseGlobalReplacements,
conversionConfig,
getTargetRuleFilename,
// Optional lifecycle hooks
...(onAdd && { onAddRulesProfile: onAdd }),
...(onRemove && { onRemoveRulesProfile: onRemove }),
...(onPostConvert && { onPostConvertRulesProfile: onPostConvert })
};
}
// Common tool mappings for editors that share similar tool sets
export const COMMON_TOOL_MAPPINGS = {
// Most editors (Cursor, Cline, Windsurf) keep original tool names
STANDARD: {},
// Roo Code uses different tool names
ROO_STYLE: {
edit_file: 'apply_diff',
search: 'search_files',
create_file: 'write_to_file',
run_command: 'execute_command',
terminal_command: 'execute_command',
use_mcp: 'use_mcp_tool'
}
};

59
scripts/profiles/claude.js
View File

@@ -1,59 +0,0 @@
// Claude Code profile for rule-transformer
import path from 'path';
import fs from 'fs';
import { isSilentMode, log } from '../modules/utils.js';
// Lifecycle functions for Claude Code profile
function onAddRulesProfile(targetDir, assetsDir) {
// Use the provided assets directory to find the source file
const sourceFile = path.join(assetsDir, 'AGENTS.md');
const destFile = path.join(targetDir, 'CLAUDE.md');
if (fs.existsSync(sourceFile)) {
try {
fs.copyFileSync(sourceFile, destFile);
log('debug', `[Claude] Copied AGENTS.md to ${destFile}`);
} catch (err) {
log('error', `[Claude] Failed to copy AGENTS.md: ${err.message}`);
}
}
}
function onRemoveRulesProfile(targetDir) {
const claudeFile = path.join(targetDir, 'CLAUDE.md');
if (fs.existsSync(claudeFile)) {
try {
fs.rmSync(claudeFile, { force: true });
log('debug', `[Claude] Removed CLAUDE.md from ${claudeFile}`);
} catch (err) {
log('error', `[Claude] Failed to remove CLAUDE.md: ${err.message}`);
}
}
}
function onPostConvertRulesProfile(targetDir, assetsDir) {
onAddRulesProfile(targetDir, assetsDir);
}
// Simple filename function
function getTargetRuleFilename(sourceFilename) {
return sourceFilename;
}
// Simple profile configuration - bypasses base-profile system
export const claudeProfile = {
profileName: 'claude',
displayName: 'Claude Code',
profileDir: '.', // Root directory
rulesDir: '.', // No rules directory needed
mcpConfig: false, // No MCP config needed
mcpConfigName: null,
mcpConfigPath: null,
conversionConfig: {},
fileMap: {},
globalReplacements: [],
getTargetRuleFilename,
onAddRulesProfile,
onRemoveRulesProfile,
onPostConvertRulesProfile
};

20
scripts/profiles/cline.js
View File

@@ -1,20 +0,0 @@
// Cline conversion profile for rule-transformer
import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';
// Create and export cline profile using the base factory
export const clineProfile = createProfile({
name: 'cline',
displayName: 'Cline',
url: 'cline.bot',
docsUrl: 'docs.cline.bot',
profileDir: '.clinerules',
rulesDir: '.clinerules',
mcpConfig: false,
mcpConfigName: 'cline_mcp_settings.json',
fileExtension: '.mdc',
targetExtension: '.md',
toolMappings: COMMON_TOOL_MAPPINGS.STANDARD, // Cline uses standard tool names
customFileMap: {
'cursor_rules.mdc': 'cline_rules.md'
}
});

59
scripts/profiles/codex.js
View File

@@ -1,59 +0,0 @@
// Codex profile for rule-transformer
import path from 'path';
import fs from 'fs';
import { isSilentMode, log } from '../modules/utils.js';
// Lifecycle functions for Codex profile
function onAddRulesProfile(targetDir, assetsDir) {
// Use the provided assets directory to find the source file
const sourceFile = path.join(assetsDir, 'AGENTS.md');
const destFile = path.join(targetDir, 'AGENTS.md');
if (fs.existsSync(sourceFile)) {
try {
fs.copyFileSync(sourceFile, destFile);
log('debug', `[Codex] Copied AGENTS.md to ${destFile}`);
} catch (err) {
log('error', `[Codex] Failed to copy AGENTS.md: ${err.message}`);
}
}
}
function onRemoveRulesProfile(targetDir) {
const agentsFile = path.join(targetDir, 'AGENTS.md');
if (fs.existsSync(agentsFile)) {
try {
fs.rmSync(agentsFile, { force: true });
log('debug', `[Codex] Removed AGENTS.md from ${agentsFile}`);
} catch (err) {
log('error', `[Codex] Failed to remove AGENTS.md: ${err.message}`);
}
}
}
function onPostConvertRulesProfile(targetDir, assetsDir) {
onAddRulesProfile(targetDir, assetsDir);
}
// Simple filename function
function getTargetRuleFilename(sourceFilename) {
return sourceFilename;
}
// Simple profile configuration - bypasses base-profile system
export const codexProfile = {
profileName: 'codex',
displayName: 'Codex',
profileDir: '.', // Root directory
rulesDir: '.', // No rules directory needed
mcpConfig: false, // No MCP config needed
mcpConfigName: null,
mcpConfigPath: null,
conversionConfig: {},
fileMap: {},
globalReplacements: [],
getTargetRuleFilename,
onAddRulesProfile,
onRemoveRulesProfile,
onPostConvertRulesProfile
};

21
scripts/profiles/cursor.js
View File

@@ -1,21 +0,0 @@
// Cursor conversion profile for rule-transformer
import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';
// Create and export cursor profile using the base factory
export const cursorProfile = createProfile({
name: 'cursor',
displayName: 'Cursor',
url: 'cursor.so',
docsUrl: 'docs.cursor.com',
profileDir: '.cursor',
rulesDir: '.cursor/rules',
mcpConfig: true,
mcpConfigName: 'mcp.json',
fileExtension: '.mdc',
targetExtension: '.mdc', // Cursor keeps .mdc extension
toolMappings: COMMON_TOOL_MAPPINGS.STANDARD,
supportsRulesSubdirectories: true,
customFileMap: {
'cursor_rules.mdc': 'cursor_rules.mdc' // Keep the same name for cursor
}
});

9
scripts/profiles/index.js
View File

@@ -1,9 +0,0 @@
// Profile exports for centralized importing
export { claudeProfile } from './claude.js';
export { clineProfile } from './cline.js';
export { codexProfile } from './codex.js';
export { cursorProfile } from './cursor.js';
export { rooProfile } from './roo.js';
export { traeProfile } from './trae.js';
export { vscodeProfile } from './vscode.js';
export { windsurfProfile } from './windsurf.js';

129
scripts/profiles/roo.js
View File

@@ -1,129 +0,0 @@
// Roo Code conversion profile for rule-transformer
import path from 'path';
import fs from 'fs';
import { isSilentMode, log } from '../modules/utils.js';
import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';
import { ROO_MODES } from '../../src/constants/profiles.js';
// Lifecycle functions for Roo profile
function onAddRulesProfile(targetDir, assetsDir) {
// Use the provided assets directory to find the roocode directory
const sourceDir = path.join(assetsDir, 'roocode');
if (!fs.existsSync(sourceDir)) {
log('error', `[Roo] Source directory does not exist: ${sourceDir}`);
return;
}
copyRecursiveSync(sourceDir, targetDir);
log('debug', `[Roo] Copied roocode directory to ${targetDir}`);
const rooModesDir = path.join(sourceDir, '.roo');
// Copy .roomodes to project root
const roomodesSrc = path.join(sourceDir, '.roomodes');
const roomodesDest = path.join(targetDir, '.roomodes');
if (fs.existsSync(roomodesSrc)) {
try {
fs.copyFileSync(roomodesSrc, roomodesDest);
log('debug', `[Roo] Copied .roomodes to ${roomodesDest}`);
} catch (err) {
log('error', `[Roo] Failed to copy .roomodes: ${err.message}`);
}
}
for (const mode of ROO_MODES) {
const src = path.join(rooModesDir, `rules-${mode}`, `${mode}-rules`);
const dest = path.join(targetDir, '.roo', `rules-${mode}`, `${mode}-rules`);
if (fs.existsSync(src)) {
try {
const destDir = path.dirname(dest);
if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
fs.copyFileSync(src, dest);
log('debug', `[Roo] Copied ${mode}-rules to ${dest}`);
} catch (err) {
log('error', `[Roo] Failed to copy ${src} to ${dest}: ${err.message}`);
}
}
}
}
function copyRecursiveSync(src, dest) {
const exists = fs.existsSync(src);
const stats = exists && fs.statSync(src);
const isDirectory = exists && stats.isDirectory();
if (isDirectory) {
if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
fs.readdirSync(src).forEach((childItemName) => {
copyRecursiveSync(
path.join(src, childItemName),
path.join(dest, childItemName)
);
});
} else {
fs.copyFileSync(src, dest);
}
}
function onRemoveRulesProfile(targetDir) {
const roomodesPath = path.join(targetDir, '.roomodes');
if (fs.existsSync(roomodesPath)) {
try {
fs.rmSync(roomodesPath, { force: true });
log('debug', `[Roo] Removed .roomodes from ${roomodesPath}`);
} catch (err) {
log('error', `[Roo] Failed to remove .roomodes: ${err.message}`);
}
}
const rooDir = path.join(targetDir, '.roo');
if (fs.existsSync(rooDir)) {
fs.readdirSync(rooDir).forEach((entry) => {
if (entry.startsWith('rules-')) {
const modeDir = path.join(rooDir, entry);
try {
fs.rmSync(modeDir, { recursive: true, force: true });
log('debug', `[Roo] Removed ${entry} directory from ${modeDir}`);
} catch (err) {
log('error', `[Roo] Failed to remove ${modeDir}: ${err.message}`);
}
}
});
if (fs.readdirSync(rooDir).length === 0) {
try {
fs.rmSync(rooDir, { recursive: true, force: true });
log('debug', `[Roo] Removed empty .roo directory from ${rooDir}`);
} catch (err) {
log('error', `[Roo] Failed to remove .roo directory: ${err.message}`);
}
}
}
}
function onPostConvertRulesProfile(targetDir, assetsDir) {
onAddRulesProfile(targetDir, assetsDir);
}
// Create and export roo profile using the base factory
export const rooProfile = createProfile({
name: 'roo',
displayName: 'Roo Code',
url: 'roocode.com',
docsUrl: 'docs.roocode.com',
profileDir: '.roo',
rulesDir: '.roo/rules',
mcpConfig: true,
mcpConfigName: 'mcp.json',
fileExtension: '.mdc',
targetExtension: '.md',
toolMappings: COMMON_TOOL_MAPPINGS.ROO_STYLE,
customFileMap: {
'cursor_rules.mdc': 'roo_rules.md'
},
onAdd: onAddRulesProfile,
onRemove: onRemoveRulesProfile,
onPostConvert: onPostConvertRulesProfile
});
// Export lifecycle functions separately to avoid naming conflicts
export { onAddRulesProfile, onRemoveRulesProfile, onPostConvertRulesProfile };

17
scripts/profiles/trae.js
View File

@@ -1,17 +0,0 @@
// Trae conversion profile for rule-transformer
import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';
// Create and export trae profile using the base factory
export const traeProfile = createProfile({
name: 'trae',
displayName: 'Trae',
url: 'trae.ai',
docsUrl: 'docs.trae.ai',
profileDir: '.trae',
rulesDir: '.trae/rules',
mcpConfig: false,
mcpConfigName: 'trae_mcp_settings.json',
fileExtension: '.mdc',
targetExtension: '.md',
toolMappings: COMMON_TOOL_MAPPINGS.STANDARD // Trae uses standard tool names
});

41
scripts/profiles/vscode.js
View File

@@ -1,41 +0,0 @@
// VS Code conversion profile for rule-transformer
import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';
// Create and export vscode profile using the base factory
export const vscodeProfile = createProfile({
name: 'vscode',
displayName: 'VS Code',
url: 'code.visualstudio.com',
docsUrl: 'code.visualstudio.com/docs',
profileDir: '.vscode', // MCP config location
rulesDir: '.github/instructions', // VS Code instructions location
mcpConfig: true,
mcpConfigName: 'mcp.json',
fileExtension: '.mdc',
targetExtension: '.md',
toolMappings: COMMON_TOOL_MAPPINGS.STANDARD, // VS Code uses standard tool names
customFileMap: {
'cursor_rules.mdc': 'vscode_rules.md' // Rename cursor_rules to vscode_rules
},
customReplacements: [
// Core VS Code directory structure changes
{ from: /\.cursor\/rules/g, to: '.github/instructions' },
{ from: /\.cursor\/mcp\.json/g, to: '.vscode/mcp.json' },
// Fix any remaining vscode/rules references that might be created during transformation
{ from: /\.vscode\/rules/g, to: '.github/instructions' },
// VS Code custom instructions format - use applyTo with quoted patterns instead of globs
{ from: /^globs:\s*(.+)$/gm, to: 'applyTo: "$1"' },
// Essential markdown link transformations for VS Code structure
{
from: /\[(.+?)\]\(mdc:\.cursor\/rules\/(.+?)\.mdc\)/g,
to: '[$1](.github/instructions/$2.md)'
},
// VS Code specific terminology
{ from: /rules directory/g, to: 'instructions directory' },
{ from: /cursor rules/gi, to: 'VS Code instructions' }
]
});

17
scripts/profiles/windsurf.js
View File

@@ -1,17 +0,0 @@
// Windsurf conversion profile for rule-transformer
import { createProfile, COMMON_TOOL_MAPPINGS } from './base-profile.js';
// Create and export windsurf profile using the base factory
export const windsurfProfile = createProfile({
name: 'windsurf',
displayName: 'Windsurf',
url: 'windsurf.com',
docsUrl: 'docs.windsurf.com',
profileDir: '.windsurf',
rulesDir: '.windsurf/rules',
mcpConfig: true,
mcpConfigName: 'mcp.json',
fileExtension: '.mdc',
targetExtension: '.md',
toolMappings: COMMON_TOOL_MAPPINGS.STANDARD // Windsurf uses standard tool names
});