sf-agent-framework/tools/installer/lib/ide-setup.js

AI Agent Orchestration Framework for Salesforce Development - Two-phase architecture with 70% context reduction

const path = require('path');
const fs = require('fs-extra');
const yaml = require('js-yaml');
const fileManager = require('./file-manager');
const configLoader = require('./config-loader');
const { extractYamlFromAgent } = require('../../lib/yaml-utils');

// Dynamic import for ES module
let chalk;
let inquirer;

// Initialize ES modules
async function initializeModules() {
  if (!chalk) {
    chalk = (await import('chalk')).default;
  }
  if (!inquirer) {
    inquirer = (await import('inquirer')).default;
  }
}

class IdeSetup {
  constructor() {
    this.ideAgentConfig = null;
  }

  async loadIdeAgentConfig() {
    if (this.ideAgentConfig) return this.ideAgentConfig;

    try {
      const configPath = path.join(__dirname, '..', 'config', 'ide-agent-config.yaml');
      const configContent = await fs.readFile(configPath, 'utf8');
      this.ideAgentConfig = yaml.load(configContent);
      return this.ideAgentConfig;
    } catch (error) {
      console.warn('Failed to load IDE agent configuration, using defaults');
      return {
        'roo-permissions': {},
        'cline-order': {},
      };
    }
  }

  async setup(ide, installDir, selectedAgent = null, spinner = null, preConfiguredSettings = null) {
    await initializeModules();
    const ideConfig = await configLoader.getIdeConfiguration(ide);

    if (!ideConfig) {
      console.log(chalk.yellow(`\nNo configuration available for ${ide}`));
      return false;
    }

    switch (ide) {
      case 'cursor':
        return this.setupCursor(installDir, selectedAgent);
      case 'claude-code':
        return this.setupClaudeCode(installDir, selectedAgent);
      case 'windsurf':
        return this.setupWindsurf(installDir, selectedAgent);
      case 'trae':
        return this.setupTrae(installDir, selectedAgent);
      case 'roo':
        return this.setupRoo(installDir, selectedAgent);
      case 'cline':
        return this.setupCline(installDir, selectedAgent);
      case 'gemini':
        return this.setupGeminiCli(installDir, selectedAgent);
      case 'github-copilot':
        return this.setupGitHubCopilot(installDir, selectedAgent, spinner, preConfiguredSettings);
      default:
        console.log(chalk.yellow(`\nIDE ${ide} not yet supported`));
        return false;
    }
  }

  async setupCursor(installDir, selectedAgent) {
    const cursorRulesDir = path.join(installDir, '.cursor', 'rules');
    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);

    await fileManager.ensureDirectory(cursorRulesDir);

    for (const agentId of agents) {
      // Find the agent file
      const agentPath = await this.findAgentPath(agentId, installDir);

      if (agentPath) {
        const agentContent = await fileManager.readFile(agentPath);
        const mdcPath = path.join(cursorRulesDir, `${agentId}.mdc`);

        // Create MDC content with proper format
        let mdcContent = '---\n';
        mdcContent += 'description: \n';
        mdcContent += 'globs: []\n';
        mdcContent += 'alwaysApply: false\n';
        mdcContent += '---\n\n';
        mdcContent += `# ${agentId.toUpperCase()} Agent Rule\n\n`;
        mdcContent += `This rule is triggered when the user types \`@${agentId}\` and activates the ${await this.getAgentTitle(
          agentId,
          installDir
        )} agent persona.\n\n`;
        mdcContent += '## Agent Activation\n\n';
        mdcContent +=
          'CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n';
        mdcContent += '```yaml\n';
        // Extract just the YAML content from the agent file
        const yamlContent = extractYamlFromAgent(agentContent);
        if (yamlContent) {
          mdcContent += yamlContent;
        } else {
          // If no YAML found, include the whole content minus the header
          mdcContent += agentContent.replace(/^#.*$/m, '').trim();
        }
        mdcContent += '\n```\n\n';
        mdcContent += '## File Reference\n\n';
        const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
        mdcContent += `The complete agent definition is available in [${relativePath}](mdc:${relativePath}).\n\n`;
        mdcContent += '## Usage\n\n';
        mdcContent += `When the user types \`@${agentId}\`, activate this ${await this.getAgentTitle(
          agentId,
          installDir
        )} persona and follow all instructions defined in the YAML configuration above.\n`;

        await fileManager.writeFile(mdcPath, mdcContent);
        console.log(chalk.green(`✓ Created rule: ${agentId}.mdc`));
      }
    }

    console.log(chalk.green(`\n✓ Created Cursor rules in ${cursorRulesDir}`));

    // Setup MCP configuration for Cursor
    await this.setupCursorMCP(installDir);

    return true;
  }

  async setupClaudeCode(installDir, selectedAgent) {
    // Setup sf-core commands
    const coreSlashPrefix = await this.getCoreSlashPrefix(installDir);
    const coreAgents = selectedAgent ? [selectedAgent] : await this.getCoreAgentIds(installDir);
    const coreTasks = await this.getCoreTaskIds(installDir);
    await this.setupClaudeCodeForPackage(
      installDir,
      'core',
      coreSlashPrefix,
      coreAgents,
      coreTasks,
      '.sf-core'
    );

    // Setup expansion pack commands
    const expansionPacks = await this.getInstalledExpansionPacks(installDir);
    for (const packInfo of expansionPacks) {
      const packSlashPrefix = await this.getExpansionPackSlashPrefix(packInfo.path);
      const packAgents = await this.getExpansionPackAgents(packInfo.path);
      const packTasks = await this.getExpansionPackTasks(packInfo.path);

      if (packAgents.length > 0 || packTasks.length > 0) {
        // Use the actual directory name where the expansion pack is installed
        const rootPath = path.relative(installDir, packInfo.path);
        await this.setupClaudeCodeForPackage(
          installDir,
          packInfo.name,
          packSlashPrefix,
          packAgents,
          packTasks,
          rootPath
        );
      }
    }

    // Setup MCP configuration if available
    await this.setupClaudeCodeMCP(installDir);

    return true;
  }

  async setupClaudeCodeForPackage(
    installDir,
    packageName,
    slashPrefix,
    agentIds,
    taskIds,
    rootPath
  ) {
    const commandsBaseDir = path.join(installDir, '.claude', 'commands', slashPrefix);
    const agentsDir = path.join(commandsBaseDir, 'agents');
    const tasksDir = path.join(commandsBaseDir, 'tasks');

    // Ensure directories exist
    await fileManager.ensureDirectory(agentsDir);
    await fileManager.ensureDirectory(tasksDir);

    // Setup agents
    for (const agentId of agentIds) {
      // Find the agent file - for expansion packs, prefer the expansion pack version
      let agentPath;
      if (packageName !== 'core') {
        // For expansion packs, first try to find the agent in the expansion pack directory
        const expansionPackPath = path.join(installDir, rootPath, 'agents', `${agentId}.md`);
        if (await fileManager.pathExists(expansionPackPath)) {
          agentPath = expansionPackPath;
        } else {
          // Fall back to core if not found in expansion pack
          agentPath = await this.findAgentPath(agentId, installDir);
        }
      } else {
        // For core, use the normal search
        agentPath = await this.findAgentPath(agentId, installDir);
      }

      const commandPath = path.join(agentsDir, `${agentId}.md`);

      if (agentPath) {
        // Create command file with agent content
        let agentContent = await fileManager.readFile(agentPath);

        // Replace {root} placeholder with the appropriate root path for this context
        agentContent = agentContent.replace(/{root}/g, rootPath);

        // Add command header
        let commandContent = `# /${agentId} Command\n\n`;
        commandContent += `When this command is used, adopt the following agent persona:\n\n`;
        commandContent += agentContent;

        await fileManager.writeFile(commandPath, commandContent);
        console.log(chalk.green(`✓ Created agent command: /${agentId}`));
      }
    }

    // Setup tasks
    for (const taskId of taskIds) {
      // Find the task file - for expansion packs, prefer the expansion pack version
      let taskPath;
      if (packageName !== 'core') {
        // For expansion packs, first try to find the task in the expansion pack directory
        const expansionPackPath = path.join(installDir, rootPath, 'tasks', `${taskId}.md`);
        if (await fileManager.pathExists(expansionPackPath)) {
          taskPath = expansionPackPath;
        } else {
          // Fall back to core if not found in expansion pack
          taskPath = await this.findTaskPath(taskId, installDir);
        }
      } else {
        // For core, use the normal search
        taskPath = await this.findTaskPath(taskId, installDir);
      }

      const commandPath = path.join(tasksDir, `${taskId}.md`);

      if (taskPath) {
        // Create command file with task content
        let taskContent = await fileManager.readFile(taskPath);

        // Replace {root} placeholder with the appropriate root path for this context
        taskContent = taskContent.replace(/{root}/g, rootPath);

        // Add command header
        let commandContent = `# /${taskId} Task\n\n`;
        commandContent += `When this command is used, execute the following task:\n\n`;
        commandContent += taskContent;

        await fileManager.writeFile(commandPath, commandContent);
        console.log(chalk.green(`✓ Created task command: /${taskId}`));
      }
    }

    console.log(
      chalk.green(`\n✓ Created Claude Code commands for ${packageName} in ${commandsBaseDir}`)
    );
    console.log(chalk.dim(`  - Agents in: ${agentsDir}`));
    console.log(chalk.dim(`  - Tasks in: ${tasksDir}`));
  }

  async setupWindsurf(installDir, selectedAgent) {
    const windsurfRulesDir = path.join(installDir, '.windsurf', 'rules');
    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);

    await fileManager.ensureDirectory(windsurfRulesDir);

    for (const agentId of agents) {
      // Find the agent file
      const agentPath = await this.findAgentPath(agentId, installDir);

      if (agentPath) {
        const agentContent = await fileManager.readFile(agentPath);
        const mdPath = path.join(windsurfRulesDir, `${agentId}.md`);

        // Create MD content (similar to Cursor but without frontmatter)
        let mdContent = `# ${agentId.toUpperCase()} Agent Rule\n\n`;
        mdContent += `This rule is triggered when the user types \`@${agentId}\` and activates the ${await this.getAgentTitle(
          agentId,
          installDir
        )} agent persona.\n\n`;
        mdContent += '## Agent Activation\n\n';
        mdContent +=
          'CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n';
        mdContent += '```yaml\n';
        // Extract just the YAML content from the agent file
        const yamlContent = extractYamlFromAgent(agentContent);
        if (yamlContent) {
          mdContent += yamlContent;
        } else {
          // If no YAML found, include the whole content minus the header
          mdContent += agentContent.replace(/^#.*$/m, '').trim();
        }
        mdContent += '\n```\n\n';
        mdContent += '## File Reference\n\n';
        const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
        mdContent += `The complete agent definition is available in [${relativePath}](${relativePath}).\n\n`;
        mdContent += '## Usage\n\n';
        mdContent += `When the user types \`@${agentId}\`, activate this ${await this.getAgentTitle(
          agentId,
          installDir
        )} persona and follow all instructions defined in the YAML configuration above.\n`;

        await fileManager.writeFile(mdPath, mdContent);
        console.log(chalk.green(`✓ Created rule: ${agentId}.md`));
      }
    }

    console.log(chalk.green(`\n✓ Created Windsurf rules in ${windsurfRulesDir}`));

    // Setup MCP configuration for Windsurf
    await this.setupWindsurfMCP(installDir);

    return true;
  }

  async setupTrae(installDir, selectedAgent) {
    const traeRulesDir = path.join(installDir, '.trae', 'rules');
    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);

    await fileManager.ensureDirectory(traeRulesDir);

    for (const agentId of agents) {
      // Find the agent file
      const agentPath = await this.findAgentPath(agentId, installDir);

      if (agentPath) {
        const agentContent = await fileManager.readFile(agentPath);
        const mdPath = path.join(traeRulesDir, `${agentId}.md`);

        // Create MD content (similar to Cursor but without frontmatter)
        let mdContent = `# ${agentId.toUpperCase()} Agent Rule\n\n`;
        mdContent += `This rule is triggered when the user types \`@${agentId}\` and activates the ${await this.getAgentTitle(
          agentId,
          installDir
        )} agent persona.\n\n`;
        mdContent += '## Agent Activation\n\n';
        mdContent +=
          'CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n';
        mdContent += '```yaml\n';
        // Extract just the YAML content from the agent file
        const yamlContent = extractYamlFromAgent(agentContent);
        if (yamlContent) {
          mdContent += yamlContent;
        } else {
          // If no YAML found, include the whole content minus the header
          mdContent += agentContent.replace(/^#.*$/m, '').trim();
        }
        mdContent += '\n```\n\n';
        mdContent += '## File Reference\n\n';
        const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
        mdContent += `The complete agent definition is available in [${relativePath}](${relativePath}).\n\n`;
        mdContent += '## Usage\n\n';
        mdContent += `When the user types \`@${agentId}\`, activate this ${await this.getAgentTitle(
          agentId,
          installDir
        )} persona and follow all instructions defined in the YAML configuration above.\n`;

        await fileManager.writeFile(mdPath, mdContent);
        console.log(chalk.green(`✓ Created rule: ${agentId}.md`));
      }
    }
  }

  async findAgentPath(agentId, installDir) {
    // Try to find the agent file in various locations
    const possiblePaths = [
      path.join(installDir, '.sf-core', 'agents', `${agentId}.md`),
      path.join(installDir, 'agents', `${agentId}.md`),
    ];

    // Also check expansion pack directories
    const glob = require('glob');
    const expansionDirs = glob.sync('.*/agents', { cwd: installDir });
    for (const expDir of expansionDirs) {
      possiblePaths.push(path.join(installDir, expDir, `${agentId}.md`));
    }

    for (const agentPath of possiblePaths) {
      if (await fileManager.pathExists(agentPath)) {
        return agentPath;
      }
    }

    return null;
  }

  async getAllAgentIds(installDir) {
    const glob = require('glob');
    const allAgentIds = [];

    // Check core agents in .sf-core or root
    let agentsDir = path.join(installDir, '.sf-core', 'agents');
    if (!(await fileManager.pathExists(agentsDir))) {
      agentsDir = path.join(installDir, 'agents');
    }

    if (await fileManager.pathExists(agentsDir)) {
      const agentFiles = glob.sync('*.md', { cwd: agentsDir });
      allAgentIds.push(...agentFiles.map((file) => path.basename(file, '.md')));
    }

    // Also check for expansion pack agents in dot folders
    const expansionDirs = glob.sync('.*/agents', { cwd: installDir });
    for (const expDir of expansionDirs) {
      const fullExpDir = path.join(installDir, expDir);
      const expAgentFiles = glob.sync('*.md', { cwd: fullExpDir });
      allAgentIds.push(...expAgentFiles.map((file) => path.basename(file, '.md')));
    }

    // Remove duplicates
    return [...new Set(allAgentIds)];
  }

  async getCoreAgentIds(installDir) {
    const allAgentIds = [];

    // Check core agents in .sf-core or root only
    let agentsDir = path.join(installDir, '.sf-core', 'agents');
    if (!(await fileManager.pathExists(agentsDir))) {
      agentsDir = path.join(installDir, 'sf-core', 'agents');
    }

    if (await fileManager.pathExists(agentsDir)) {
      const glob = require('glob');
      const agentFiles = glob.sync('*.md', { cwd: agentsDir });
      allAgentIds.push(...agentFiles.map((file) => path.basename(file, '.md')));
    }

    return [...new Set(allAgentIds)];
  }

  async getCoreTaskIds(installDir) {
    const allTaskIds = [];

    // Check core tasks in .sf-core or root only
    let tasksDir = path.join(installDir, '.sf-core', 'tasks');
    if (!(await fileManager.pathExists(tasksDir))) {
      tasksDir = path.join(installDir, 'sf-core', 'tasks');
    }

    if (await fileManager.pathExists(tasksDir)) {
      const glob = require('glob');
      const taskFiles = glob.sync('*.md', { cwd: tasksDir });
      allTaskIds.push(...taskFiles.map((file) => path.basename(file, '.md')));
    }

    // Check common tasks
    const commonTasksDir = path.join(installDir, 'common', 'tasks');
    if (await fileManager.pathExists(commonTasksDir)) {
      const commonTaskFiles = glob.sync('*.md', { cwd: commonTasksDir });
      allTaskIds.push(...commonTaskFiles.map((file) => path.basename(file, '.md')));
    }

    return [...new Set(allTaskIds)];
  }

  async getAgentTitle(agentId, installDir) {
    // Try to find the agent file in various locations
    const possiblePaths = [
      path.join(installDir, '.sf-core', 'agents', `${agentId}.md`),
      path.join(installDir, 'agents', `${agentId}.md`),
    ];

    // Also check expansion pack directories
    const glob = require('glob');
    const expansionDirs = glob.sync('.*/agents', { cwd: installDir });
    for (const expDir of expansionDirs) {
      possiblePaths.push(path.join(installDir, expDir, `${agentId}.md`));
    }

    for (const agentPath of possiblePaths) {
      if (await fileManager.pathExists(agentPath)) {
        try {
          const agentContent = await fileManager.readFile(agentPath);
          const yamlMatch = agentContent.match(/```ya?ml\r?\n([\s\S]*?)```/);

          if (yamlMatch) {
            const yaml = yamlMatch[1];
            const titleMatch = yaml.match(/title:\s*(.+)/);
            if (titleMatch) {
              return titleMatch[1].trim();
            }
          }
        } catch (error) {
          console.warn(`Failed to read agent title for ${agentId}: ${error.message}`);
        }
      }
    }

    // Fallback to formatted agent ID
    return agentId
      .split('-')
      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
      .join(' ');
  }

  async getAllTaskIds(installDir) {
    const glob = require('glob');
    const allTaskIds = [];

    // Check core tasks in .sf-core or root
    let tasksDir = path.join(installDir, '.sf-core', 'tasks');
    if (!(await fileManager.pathExists(tasksDir))) {
      tasksDir = path.join(installDir, 'sf-core', 'tasks');
    }

    if (await fileManager.pathExists(tasksDir)) {
      const taskFiles = glob.sync('*.md', { cwd: tasksDir });
      allTaskIds.push(...taskFiles.map((file) => path.basename(file, '.md')));
    }

    // Check common tasks
    const commonTasksDir = path.join(installDir, 'common', 'tasks');
    if (await fileManager.pathExists(commonTasksDir)) {
      const commonTaskFiles = glob.sync('*.md', { cwd: commonTasksDir });
      allTaskIds.push(...commonTaskFiles.map((file) => path.basename(file, '.md')));
    }

    // Also check for expansion pack tasks in dot folders
    const expansionDirs = glob.sync('.*/tasks', { cwd: installDir });
    for (const expDir of expansionDirs) {
      const fullExpDir = path.join(installDir, expDir);
      const expTaskFiles = glob.sync('*.md', { cwd: fullExpDir });
      allTaskIds.push(...expTaskFiles.map((file) => path.basename(file, '.md')));
    }

    // Check expansion-packs folder tasks
    const expansionPacksDir = path.join(installDir, 'expansion-packs');
    if (await fileManager.pathExists(expansionPacksDir)) {
      const expPackDirs = glob.sync('*/tasks', { cwd: expansionPacksDir });
      for (const expDir of expPackDirs) {
        const fullExpDir = path.join(expansionPacksDir, expDir);
        const expTaskFiles = glob.sync('*.md', { cwd: fullExpDir });
        allTaskIds.push(...expTaskFiles.map((file) => path.basename(file, '.md')));
      }
    }

    // Remove duplicates
    return [...new Set(allTaskIds)];
  }

  async findTaskPath(taskId, installDir) {
    // Try to find the task file in various locations
    const possiblePaths = [
      path.join(installDir, '.sf-core', 'tasks', `${taskId}.md`),
      path.join(installDir, 'sf-core', 'tasks', `${taskId}.md`),
      path.join(installDir, 'common', 'tasks', `${taskId}.md`),
    ];

    // Also check expansion pack directories
    const glob = require('glob');

    // Check dot folder expansion packs
    const expansionDirs = glob.sync('.*/tasks', { cwd: installDir });
    for (const expDir of expansionDirs) {
      possiblePaths.push(path.join(installDir, expDir, `${taskId}.md`));
    }

    // Check expansion-packs folder
    const expansionPacksDir = path.join(installDir, 'expansion-packs');
    if (await fileManager.pathExists(expansionPacksDir)) {
      const expPackDirs = glob.sync('*/tasks', { cwd: expansionPacksDir });
      for (const expDir of expPackDirs) {
        possiblePaths.push(path.join(expansionPacksDir, expDir, `${taskId}.md`));
      }
    }

    for (const taskPath of possiblePaths) {
      if (await fileManager.pathExists(taskPath)) {
        return taskPath;
      }
    }

    return null;
  }

  async getCoreSlashPrefix(installDir) {
    try {
      const coreConfigPath = path.join(installDir, '.sf-core', 'core-config.yaml');
      if (!(await fileManager.pathExists(coreConfigPath))) {
        // Try sf-core directory
        const altConfigPath = path.join(installDir, 'sf-core', 'core-config.yaml');
        if (await fileManager.pathExists(altConfigPath)) {
          const configContent = await fileManager.readFile(altConfigPath);
          const config = yaml.load(configContent);
          return config.slashPrefix || 'SF-Agent';
        }
        return 'SF-Agent'; // fallback
      }

      const configContent = await fileManager.readFile(coreConfigPath);
      const config = yaml.load(configContent);
      return config.slashPrefix || 'SF-Agent';
    } catch (error) {
      console.warn(`Failed to read core slashPrefix, using default 'SF-Agent': ${error.message}`);
      return 'SF-Agent';
    }
  }

  async getInstalledExpansionPacks(installDir) {
    const expansionPacks = [];

    // Check for dot-prefixed expansion packs in install directory
    const glob = require('glob');
    const dotExpansions = glob.sync('.sfAgent-*', { cwd: installDir });

    for (const dotExpansion of dotExpansions) {
      if (dotExpansion !== '.sf-core') {
        const packPath = path.join(installDir, dotExpansion);
        const packName = dotExpansion.substring(1); // remove the dot
        expansionPacks.push({
          name: packName,
          path: packPath,
        });
      }
    }

    // Check for expansion-packs directory style
    const expansionPacksDir = path.join(installDir, 'expansion-packs');
    if (await fileManager.pathExists(expansionPacksDir)) {
      const packDirs = glob.sync('*', { cwd: expansionPacksDir });

      for (const packDir of packDirs) {
        const packPath = path.join(expansionPacksDir, packDir);
        if (
          (await fileManager.pathExists(packPath)) &&
          (await fileManager.pathExists(path.join(packPath, 'config.yaml')))
        ) {
          expansionPacks.push({
            name: packDir,
            path: packPath,
          });
        }
      }
    }

    return expansionPacks;
  }

  async getExpansionPackSlashPrefix(packPath) {
    try {
      const configPath = path.join(packPath, 'config.yaml');
      if (await fileManager.pathExists(configPath)) {
        const configContent = await fileManager.readFile(configPath);
        const config = yaml.load(configContent);
        return config.slashPrefix || path.basename(packPath);
      }
    } catch (error) {
      console.warn(`Failed to read expansion pack slashPrefix from ${packPath}: ${error.message}`);
    }

    return path.basename(packPath); // fallback to directory name
  }

  async getExpansionPackAgents(packPath) {
    const agentsDir = path.join(packPath, 'agents');
    if (!(await fileManager.pathExists(agentsDir))) {
      return [];
    }

    try {
      const glob = require('glob');
      const agentFiles = glob.sync('*.md', { cwd: agentsDir });
      return agentFiles.map((file) => path.basename(file, '.md'));
    } catch (error) {
      console.warn(`Failed to read expansion pack agents from ${packPath}: ${error.message}`);
      return [];
    }
  }

  async getExpansionPackTasks(packPath) {
    const tasksDir = path.join(packPath, 'tasks');
    if (!(await fileManager.pathExists(tasksDir))) {
      return [];
    }

    try {
      const glob = require('glob');
      const taskFiles = glob.sync('*.md', { cwd: tasksDir });
      return taskFiles.map((file) => path.basename(file, '.md'));
    } catch (error) {
      console.warn(`Failed to read expansion pack tasks from ${packPath}: ${error.message}`);
      return [];
    }
  }

  async setupRoo(installDir, selectedAgent) {
    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);

    // Check for existing .roomodes file in project root
    const roomodesPath = path.join(installDir, '.roomodes');
    let existingModes = [];
    let existingContent = '';

    if (await fileManager.pathExists(roomodesPath)) {
      existingContent = await fileManager.readFile(roomodesPath);
      // Parse existing modes to avoid duplicates
      const modeMatches = existingContent.matchAll(/- slug: ([\w-]+)/g);
      for (const match of modeMatches) {
        existingModes.push(match[1]);
      }
      console.log(chalk.yellow(`Found existing .roomodes file with ${existingModes.length} modes`));
    }

    // Create new modes content
    let newModesContent = '';

    // Load dynamic agent permissions from configuration
    const config = await this.loadIdeAgentConfig();
    const agentPermissions = config['roo-permissions'] || {};

    for (const agentId of agents) {
      // Skip if already exists
      // Check both with and without sf-agent- prefix to handle both cases
      const checkSlug = agentId.startsWith('sf-agent-') ? agentId : `sf-agent-${agentId}`;
      if (existingModes.includes(checkSlug)) {
        console.log(chalk.dim(`Skipping ${agentId} - already exists in .roomodes`));
        continue;
      }

      // Read agent file to extract all information
      const agentPath = await this.findAgentPath(agentId, installDir);

      if (agentPath) {
        const agentContent = await fileManager.readFile(agentPath);

        // Extract YAML content
        const yamlMatch = agentContent.match(/```ya?ml\r?\n([\s\S]*?)```/);
        if (yamlMatch) {
          const yaml = yamlMatch[1];

          // Extract agent info from YAML
          const titleMatch = yaml.match(/title:\s*(.+)/);
          const iconMatch = yaml.match(/icon:\s*(.+)/);
          const whenToUseMatch = yaml.match(/whenToUse:\s*"(.+)"/);
          const roleDefinitionMatch = yaml.match(/roleDefinition:\s*"(.+)"/);

          const title = titleMatch
            ? titleMatch[1].trim()
            : await this.getAgentTitle(agentId, installDir);
          const icon = iconMatch ? iconMatch[1].trim() : '🤖';
          const whenToUse = whenToUseMatch ? whenToUseMatch[1].trim() : `Use for ${title} tasks`;
          const roleDefinition = roleDefinitionMatch
            ? roleDefinitionMatch[1].trim()
            : `You are a ${title} specializing in ${title.toLowerCase()} tasks and responsibilities.`;

          // Build mode entry with proper formatting (matching exact indentation)
          // Avoid double "sf-agent-" prefix for agents that already have it
          const slug = agentId.startsWith('sf-agent-') ? agentId : `sf-agent-${agentId}`;
          newModesContent += ` - slug: ${slug}\n`;
          newModesContent += `   name: '${icon} ${title}'\n`;
          newModesContent += `   roleDefinition: ${roleDefinition}\n`;
          newModesContent += `   whenToUse: ${whenToUse}\n`;
          // Get relative path from installDir to agent file
          const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
          newModesContent += `   customInstructions: CRITICAL Read the full YAML from ${relativePath} start activation to alter your state of being follow startup section instructions stay in this being until told to exit this mode\n`;
          newModesContent += `   groups:\n`;
          newModesContent += `    - read\n`;

          // Add permissions based on agent type
          const permissions = agentPermissions[agentId];
          if (permissions) {
            newModesContent += `    - - edit\n`;
            newModesContent += `      - fileRegex: ${permissions.fileRegex}\n`;
            newModesContent += `        description: ${permissions.description}\n`;
          } else {
            newModesContent += `    - edit\n`;
          }

          console.log(chalk.green(`✓ Added mode: sf-agent-${agentId} (${icon} ${title})`));
        }
      }
    }

    // Build final roomodes content
    let roomodesContent = '';
    if (existingContent) {
      // If there's existing content, append new modes to it
      roomodesContent = existingContent.trim() + '\n' + newModesContent;
    } else {
      // Create new .roomodes file with proper YAML structure
      roomodesContent = 'customModes:\n' + newModesContent;
    }

    // Write .roomodes file
    await fileManager.writeFile(roomodesPath, roomodesContent);
    console.log(chalk.green('✓ Created .roomodes file in project root'));

    console.log(chalk.green(`\n✓ Roo Code setup complete!`));
    console.log(chalk.dim('Custom modes will be available when you open this project in Roo Code'));

    return true;
  }

  async setupCline(installDir, selectedAgent) {
    const clineRulesDir = path.join(installDir, '.clinerules');
    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);

    await fileManager.ensureDirectory(clineRulesDir);

    // Load dynamic agent ordering from configuration
    const config = await this.loadIdeAgentConfig();
    const agentOrder = config['cline-order'] || {};

    for (const agentId of agents) {
      // Find the agent file
      const agentPath = await this.findAgentPath(agentId, installDir);

      if (agentPath) {
        const agentContent = await fileManager.readFile(agentPath);

        // Get numeric prefix for ordering
        const order = agentOrder[agentId] || 99;
        const prefix = order.toString().padStart(2, '0');
        const mdPath = path.join(clineRulesDir, `${prefix}-${agentId}.md`);

        // Create MD content for Cline (focused on project standards and role)
        let mdContent = `# ${await this.getAgentTitle(agentId, installDir)} Agent\n\n`;
        mdContent += `This rule defines the ${await this.getAgentTitle(agentId, installDir)} persona and project standards.\n\n`;
        mdContent += '## Role Definition\n\n';
        mdContent +=
          'When the user types `@' +
          agentId +
          '`, adopt this persona and follow these guidelines:\n\n';
        mdContent += '```yaml\n';
        // Extract just the YAML content from the agent file
        const yamlContent = extractYamlFromAgent(agentContent);
        if (yamlContent) {
          mdContent += yamlContent;
        } else {
          // If no YAML found, include the whole content minus the header
          mdContent += agentContent.replace(/^#.*$/m, '').trim();
        }
        mdContent += '\n```\n\n';
        mdContent += '## Project Standards\n\n';
        mdContent += `- Always maintain consistency with project documentation in .sf-core/\n`;
        mdContent += `- Follow the agent's specific guidelines and constraints\n`;
        mdContent += `- Update relevant project files when making changes\n`;
        const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
        mdContent += `- Reference the complete agent definition in [${relativePath}](${relativePath})\n\n`;
        mdContent += '## Usage\n\n';
        mdContent += `Type \`@${agentId}\` to activate this ${await this.getAgentTitle(agentId, installDir)} persona.\n`;

        await fileManager.writeFile(mdPath, mdContent);
        console.log(chalk.green(`✓ Created rule: ${prefix}-${agentId}.md`));
      }
    }

    console.log(chalk.green(`\n✓ Created Cline rules in ${clineRulesDir}`));

    return true;
  }

  async setupGeminiCli(installDir) {
    await initializeModules();
    const geminiDir = path.join(installDir, '.gemini');
    const sfAgentMethodDir = path.join(geminiDir, 'sf-agent-framework');
    await fileManager.ensureDirectory(sfAgentMethodDir);

    // Update logic for existing settings.json
    const settingsPath = path.join(geminiDir, 'settings.json');
    if (await fileManager.pathExists(settingsPath)) {
      try {
        const settingsContent = await fileManager.readFile(settingsPath);
        const settings = JSON.parse(settingsContent);
        let updated = false;

        // Handle contextFileName property
        if (settings.contextFileName && Array.isArray(settings.contextFileName)) {
          const originalLength = settings.contextFileName.length;
          settings.contextFileName = settings.contextFileName.filter(
            (fileName) => !fileName.startsWith('agents/')
          );
          if (settings.contextFileName.length !== originalLength) {
            updated = true;
          }
        }

        if (updated) {
          await fileManager.writeFile(settingsPath, JSON.stringify(settings, null, 2));
          console.log(
            chalk.green('✓ Updated .gemini/settings.json - removed agent file references')
          );
        }
      } catch (error) {
        console.warn(chalk.yellow('Could not update .gemini/settings.json'), error);
      }
    }

    // Remove old agents directory
    const agentsDir = path.join(geminiDir, 'agents');
    if (await fileManager.pathExists(agentsDir)) {
      await fileManager.removeDirectory(agentsDir);
      console.log(chalk.green('✓ Removed old .gemini/agents directory'));
    }

    // Get all available agents
    const agents = await this.getAllAgentIds(installDir);
    let concatenatedContent = '';

    for (const agentId of agents) {
      // Find the source agent file
      const agentPath = await this.findAgentPath(agentId, installDir);

      if (agentPath) {
        const agentContent = await fileManager.readFile(agentPath);

        // Create properly formatted agent rule content (similar to trae)
        let agentRuleContent = `# ${agentId.toUpperCase()} Agent Rule\n\n`;
        agentRuleContent += `This rule is triggered when the user types \`*${agentId}\` and activates the ${await this.getAgentTitle(
          agentId,
          installDir
        )} agent persona.\n\n`;
        agentRuleContent += '## Agent Activation\n\n';
        agentRuleContent +=
          'CRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n';
        agentRuleContent += '```yaml\n';
        // Extract just the YAML content from the agent file
        const yamlContent = extractYamlFromAgent(agentContent);
        if (yamlContent) {
          agentRuleContent += yamlContent;
        } else {
          // If no YAML found, include the whole content minus the header
          agentRuleContent += agentContent.replace(/^#.*$/m, '').trim();
        }
        agentRuleContent += '\n```\n\n';
        agentRuleContent += '## File Reference\n\n';
        const relativePath = path.relative(installDir, agentPath).replace(/\\/g, '/');
        agentRuleContent += `The complete agent definition is available in [${relativePath}](${relativePath}).\n\n`;
        agentRuleContent += '## Usage\n\n';
        agentRuleContent += `When the user types \`*${agentId}\`, activate this ${await this.getAgentTitle(
          agentId,
          installDir
        )} persona and follow all instructions defined in the YAML configuration above.\n`;

        // Add to concatenated content with separator
        concatenatedContent += agentRuleContent + '\n\n---\n\n';
        console.log(chalk.green(`✓ Added context for @${agentId}`));
      }
    }

    // Write the concatenated content to GEMINI.md
    const geminiMdPath = path.join(sfAgentMethodDir, 'GEMINI.md');
    await fileManager.writeFile(geminiMdPath, concatenatedContent);
    console.log(chalk.green(`\n✓ Created GEMINI.md in ${sfAgentMethodDir}`));

    return true;
  }

  async setupGitHubCopilot(
    installDir,
    selectedAgent,
    spinner = null,
    preConfiguredSettings = null
  ) {
    await initializeModules();

    // Configure VS Code workspace settings first to avoid UI conflicts with loading spinners
    await this.configureVsCodeSettings(installDir, spinner, preConfiguredSettings);

    const chatmodesDir = path.join(installDir, '.github', 'chatmodes');
    const agents = selectedAgent ? [selectedAgent] : await this.getAllAgentIds(installDir);

    await fileManager.ensureDirectory(chatmodesDir);

    for (const agentId of agents) {
      // Find the agent file
      const agentPath = await this.findAgentPath(agentId, installDir);
      const chatmodePath = path.join(chatmodesDir, `${agentId}.chatmode.md`);

      if (agentPath) {
        // Create chat mode file with agent content
        const agentContent = await fileManager.readFile(agentPath);
        const agentTitle = await this.getAgentTitle(agentId, installDir);

        // Extract whenToUse for the description
        const yamlMatch = agentContent.match(/```ya?ml\r?\n([\s\S]*?)```/);
        let description = `Activates the ${agentTitle} agent persona.`;
        if (yamlMatch) {
          const whenToUseMatch = yamlMatch[1].match(/whenToUse:\s*"(.*?)"/);
          if (whenToUseMatch && whenToUseMatch[1]) {
            description = whenToUseMatch[1];
          }
        }

        let chatmodeContent = `---
description: "${description.replace(/"/g, '\\"')}"
tools: ['changes', 'codebase', 'editFiles', 'extensions', 'fetch', 'findTestFiles', 'githubRepo', 'new', 'openSimpleBrowser', 'problems', 'runCommands', 'runNotebooks', 'runTasks', 'runTests', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
---

`;
        chatmodeContent += agentContent;

        await fileManager.writeFile(chatmodePath, chatmodeContent);
        console.log(chalk.green(`✓ Created chat mode: ${agentId}.chatmode.md`));
      }
    }

    console.log(chalk.green(`\n✓ Github Copilot setup complete!`));
    console.log(
      chalk.dim(`You can now find the SF-Agent agents in the Chat view's mode selector.`)
    );

    // Setup MCP configuration for GitHub Copilot
    await this.setupGitHubCopilotMCP(installDir);

    return true;
  }

  async configureVsCodeSettings(installDir, spinner, preConfiguredSettings = null) {
    await initializeModules(); // Ensure inquirer is loaded
    const vscodeDir = path.join(installDir, '.vscode');
    const settingsPath = path.join(vscodeDir, 'settings.json');

    await fileManager.ensureDirectory(vscodeDir);

    // Read existing settings if they exist
    let existingSettings = {};
    if (await fileManager.pathExists(settingsPath)) {
      try {
        const existingContent = await fileManager.readFile(settingsPath);
        existingSettings = JSON.parse(existingContent);
        console.log(
          chalk.yellow('Found existing .vscode/settings.json. Merging SF-Agent settings...')
        );
      } catch (error) {
        console.warn(chalk.yellow('Could not parse existing settings.json. Creating new one.'));
        existingSettings = {};
      }
    }

    // Use pre-configured settings if provided, otherwise prompt
    let configChoice;
    if (preConfiguredSettings && preConfiguredSettings.configChoice) {
      configChoice = preConfiguredSettings.configChoice;
      console.log(chalk.dim(`Using pre-configured GitHub Copilot settings: ${configChoice}`));
    } else {
      // Clear any previous output and add spacing to avoid conflicts with loaders
      console.log('\n'.repeat(2));
      console.log(chalk.blue('🔧 Github Copilot Agent Settings Configuration'));
      console.log(
        chalk.dim(
          'SF-Agent works best with specific VS Code settings for optimal agent experience.'
        )
      );
      console.log(''); // Add extra spacing

      const response = await inquirer.prompt([
        {
          type: 'list',
          name: 'configChoice',
          message: chalk.yellow('How would you like to configure GitHub Copilot settings?'),
          choices: [
            {
              name: 'Use recommended defaults (fastest setup)',
              value: 'defaults',
            },
            {
              name: 'Configure each setting manually (customize to your preferences)',
              value: 'manual',
            },
            {
              name: "Skip settings configuration (I'll configure manually later)",
              value: 'skip',
            },
          ],
          default: 'defaults',
        },
      ]);
      configChoice = response.configChoice;
    }

    let sfAgentSettings = {};

    if (configChoice === 'skip') {
      console.log(chalk.yellow('⚠️  Skipping VS Code settings configuration.'));
      console.log(chalk.dim('You can manually configure these settings in .vscode/settings.json:'));
      console.log(chalk.dim('  • chat.agent.enabled: true'));
      console.log(chalk.dim('  • chat.agent.maxRequests: 15'));
      console.log(chalk.dim('  • github.copilot.chat.agent.runTasks: true'));
      console.log(chalk.dim('  • chat.mcp.discovery.enabled: true'));
      console.log(chalk.dim('  • github.copilot.chat.agent.autoFix: true'));
      console.log(chalk.dim('  • chat.tools.autoApprove: false'));
      return true;
    }

    if (configChoice === 'defaults') {
      // Use recommended defaults
      sfAgentSettings = {
        'chat.agent.enabled': true,
        'chat.agent.maxRequests': 15,
        'github.copilot.chat.agent.runTasks': true,
        'chat.mcp.discovery.enabled': true,
        'github.copilot.chat.agent.autoFix': true,
        'chat.tools.autoApprove': false,
      };
      console.log(chalk.green('✓ Using recommended SF-Agent defaults for Github Copilot settings'));
    } else {
      // Manual configuration
      console.log(chalk.blue("\n📋 Let's configure each setting for your preferences:"));

      // Pause spinner during manual configuration prompts
      let spinnerWasActive = false;
      if (spinner && spinner.isSpinning) {
        spinner.stop();
        spinnerWasActive = true;
      }

      const manualSettings = await inquirer.prompt([
        {
          type: 'input',
          name: 'maxRequests',
          message: 'Maximum requests per agent session (recommended: 15)?',
          default: '15',
          validate: (input) => {
            const num = parseInt(input);
            if (isNaN(num) || num < 1 || num > 50) {
              return 'Please enter a number between 1 and 50';
            }
            return true;
          },
        },
        {
          type: 'confirm',
          name: 'runTasks',
          message: 'Allow agents to run workspace tasks (package.json scripts, etc.)?',
          default: true,
        },
        {
          type: 'confirm',
          name: 'mcpDiscovery',
          message: 'Enable MCP (Model Context Protocol) server discovery?',
          default: true,
        },
        {
          type: 'confirm',
          name: 'autoFix',
          message: 'Enable automatic error detection and fixing in generated code?',
          default: true,
        },
        {
          type: 'confirm',
          name: 'autoApprove',
          message: 'Auto-approve ALL tools without confirmation? (⚠️  EXPERIMENTAL - less secure)',
          default: false,
        },
      ]);

      // Restart spinner if it was active before prompts
      if (spinner && spinnerWasActive) {
        spinner.start();
      }

      sfAgentSettings = {
        'chat.agent.enabled': true, // Always enabled - required for SF-Agent agents
        'chat.agent.maxRequests': parseInt(manualSettings.maxRequests),
        'github.copilot.chat.agent.runTasks': manualSettings.runTasks,
        'chat.mcp.discovery.enabled': manualSettings.mcpDiscovery,
        'github.copilot.chat.agent.autoFix': manualSettings.autoFix,
        'chat.tools.autoApprove': manualSettings.autoApprove,
      };

      console.log(chalk.green('✓ Custom settings configured'));
    }

    // Merge settings (existing settings take precedence to avoid overriding user preferences)
    const mergedSettings = { ...sfAgentSettings, ...existingSettings };

    // Write the updated settings
    await fileManager.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));

    console.log(chalk.green('✓ VS Code workspace settings configured successfully'));
    console.log(chalk.dim('  Settings written to .vscode/settings.json:'));
    Object.entries(sfAgentSettings).forEach(([key, value]) => {
      console.log(chalk.dim(`  • ${key}: ${value}`));
    });
    console.log(chalk.dim(''));
    console.log(chalk.dim('You can modify these settings anytime in .vscode/settings.json'));
  }

  async setupClaudeCodeMCP(installDir) {
    await initializeModules();

    // Check for MCP configurations in expansion packs
    const mcpConfigs = [];
    const expansionPacks = await this.getInstalledExpansionPacks(installDir);

    for (const packInfo of expansionPacks) {
      const mcpDir = path.join(packInfo.path, 'mcp');
      if (await fileManager.pathExists(mcpDir)) {
        // Look for MCP server configurations
        const serversDir = path.join(mcpDir, 'servers');
        if (await fileManager.pathExists(serversDir)) {
          const glob = require('glob');
          const serverFiles = glob.sync('*.js', { cwd: serversDir });

          for (const serverFile of serverFiles) {
            const serverName = path.basename(serverFile, '.js');
            mcpConfigs.push({
              packName: packInfo.name,
              serverName,
              serverPath: path.join(serversDir, serverFile),
              relativePath: path.relative(installDir, path.join(serversDir, serverFile)),
            });
          }
        }
      }
    }

    if (mcpConfigs.length === 0) {
      return; // No MCP configurations found
    }

    // Create MCP configuration for Claude Code
    const claudeDir = path.join(installDir, '.claude');
    const mcpConfigPath = path.join(claudeDir, 'claude_mcp_config.json');

    await fileManager.ensureDirectory(claudeDir);

    // Load MCP settings from ide-agent-config
    const config = await this.loadIdeAgentConfig();
    const mcpSettings = config['mcp-settings'] || {};
    const claudeMcpSettings = mcpSettings['claude-code'] || {};

    // Build MCP configuration
    const mcpConfig = {
      mcp: {
        servers: {},
      },
    };

    // Add discovered MCP servers
    for (const server of mcpConfigs) {
      const serverKey = `${server.packName}-${server.serverName}`;
      mcpConfig.mcp.servers[serverKey] = {
        command: 'node',
        args: [server.relativePath],
        env: {
          SF_LOGIN_URL: '${SF_LOGIN_URL}',
          SF_USERNAME: '${SF_USERNAME}',
          SF_PASSWORD: '${SF_PASSWORD}',
          SF_SECURITY_TOKEN: '${SF_SECURITY_TOKEN}',
          SF_API_VERSION: '${SF_API_VERSION:-59.0}',
        },
        capabilities: claudeMcpSettings.defaultServers?.[0]?.capabilities || {
          tools: true,
          resources: true,
          prompts: true,
        },
      };

      console.log(chalk.green(`✓ Configured MCP server: ${serverKey}`));
    }

    // Write MCP configuration
    await fileManager.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
    console.log(chalk.green(`\n✓ Created Claude Code MCP configuration in ${mcpConfigPath}`));
    console.log(
      chalk.dim('  Note: Update environment variables in the config file with actual values')
    );

    // Create sample .env file if it doesn't exist
    const envPath = path.join(installDir, '.env.mcp.example');
    if (!(await fileManager.pathExists(envPath))) {
      const envContent = `# Salesforce MCP Configuration
SF_LOGIN_URL=https://login.salesforce.com
SF_USERNAME=your.username@company.com
SF_PASSWORD=yourpassword
SF_SECURITY_TOKEN=yoursecuritytoken
SF_API_VERSION=59.0

# OAuth Configuration (optional)
SF_CLIENT_ID=yourclientid
SF_CLIENT_SECRET=yourclientsecret
SF_REDIRECT_URI=http://localhost:3000/callback

# MCP Server Settings
MCP_SERVER_PORT=3001
MCP_LOG_LEVEL=info
`;

      await fileManager.writeFile(envPath, envContent);
      console.log(chalk.dim(`  Created example environment file: ${envPath}`));
    }
  }

  // MCP Setup Methods for All IDEs

  async setupCursorMCP(installDir) {
    await initializeModules();

    // Check for MCP servers
    const mcpServers = await this.discoverMCPServers