bmad-method 5.1.3 → 6.0.0-alpha.0

package/tools/cli/installers/lib/ide/_base-ide.js

@@ -0,0 +1,281 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const { XmlHandler } = require('../../../lib/xml-handler');
+const { getSourcePath } = require('../../../lib/project-root');
+
+/**
+ * Base class for IDE-specific setup
+ * All IDE handlers should extend this class
+ */
+class BaseIdeSetup {
+  constructor(name, displayName = null, preferred = false) {
+    this.name = name;
+    this.displayName = displayName || name; // Human-readable name for UI
+    this.preferred = preferred; // Whether this IDE should be shown in preferred list
+    this.configDir = null; // Override in subclasses
+    this.rulesDir = null; // Override in subclasses
+    this.xmlHandler = new XmlHandler();
+  }
+
+  /**
+   * Main setup method - must be implemented by subclasses
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    throw new Error(`setup() must be implemented by ${this.name} handler`);
+  }
+
+  /**
+   * Cleanup IDE configuration
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    // Default implementation - can be overridden
+    if (this.configDir) {
+      const configPath = path.join(projectDir, this.configDir);
+      if (await fs.pathExists(configPath)) {
+        const bmadRulesPath = path.join(configPath, 'bmad');
+        if (await fs.pathExists(bmadRulesPath)) {
+          await fs.remove(bmadRulesPath);
+          console.log(chalk.dim(`Removed ${this.name} BMAD configuration`));
+        }
+      }
+    }
+  }
+
+  /**
+   * Get list of agents from BMAD installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {Array} List of agent files
+   */
+  async getAgents(bmadDir) {
+    const agents = [];
+
+    // Get core agents
+    const coreAgentsPath = path.join(bmadDir, 'core', 'agents');
+    if (await fs.pathExists(coreAgentsPath)) {
+      const coreAgents = await this.scanDirectory(coreAgentsPath, '.md');
+      agents.push(
+        ...coreAgents.map((a) => ({
+          ...a,
+          module: 'core',
+        })),
+      );
+    }
+
+    // Get module agents
+    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
+        const moduleAgentsPath = path.join(bmadDir, entry.name, 'agents');
+        if (await fs.pathExists(moduleAgentsPath)) {
+          const moduleAgents = await this.scanDirectory(moduleAgentsPath, '.md');
+          agents.push(
+            ...moduleAgents.map((a) => ({
+              ...a,
+              module: entry.name,
+            })),
+          );
+        }
+      }
+    }
+
+    return agents;
+  }
+
+  /**
+   * Get list of tasks from BMAD installation
+   * @param {string} bmadDir - BMAD installation directory
+   * @returns {Array} List of task files
+   */
+  async getTasks(bmadDir) {
+    const tasks = [];
+
+    // Get core tasks
+    const coreTasksPath = path.join(bmadDir, 'core', 'tasks');
+    if (await fs.pathExists(coreTasksPath)) {
+      const coreTasks = await this.scanDirectory(coreTasksPath, '.md');
+      tasks.push(
+        ...coreTasks.map((t) => ({
+          ...t,
+          module: 'core',
+        })),
+      );
+    }
+
+    // Get module tasks
+    const entries = await fs.readdir(bmadDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name !== 'core' && entry.name !== '_cfg') {
+        const moduleTasksPath = path.join(bmadDir, entry.name, 'tasks');
+        if (await fs.pathExists(moduleTasksPath)) {
+          const moduleTasks = await this.scanDirectory(moduleTasksPath, '.md');
+          tasks.push(
+            ...moduleTasks.map((t) => ({
+              ...t,
+              module: entry.name,
+            })),
+          );
+        }
+      }
+    }
+
+    return tasks;
+  }
+
+  /**
+   * Scan a directory for files with specific extension
+   * @param {string} dir - Directory to scan
+   * @param {string} ext - File extension to match
+   * @returns {Array} List of file info objects
+   */
+  async scanDirectory(dir, ext) {
+    const files = [];
+
+    if (!(await fs.pathExists(dir))) {
+      return files;
+    }
+
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively scan subdirectories
+        const subFiles = await this.scanDirectory(fullPath, ext);
+        files.push(...subFiles);
+      } else if (entry.isFile() && entry.name.endsWith(ext)) {
+        files.push({
+          name: path.basename(entry.name, ext),
+          path: fullPath,
+          relativePath: path.relative(dir, fullPath),
+          filename: entry.name,
+        });
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Create IDE command/rule file from agent or task
+   * @param {string} content - File content
+   * @param {Object} metadata - File metadata
+   * @param {string} projectDir - The actual project directory path
+   * @returns {string} Processed content
+   */
+  processContent(content, metadata = {}, projectDir = null) {
+    // Replace placeholders
+    let processed = content;
+
+    // Inject activation block for agent files FIRST (before replacements)
+    if (metadata.name && content.includes('<agent')) {
+      processed = this.xmlHandler.injectActivationSimple(processed, metadata);
+    }
+
+    // Use the actual project directory path if provided, otherwise default to 'bmad/'
+    const projectRoot = projectDir ? projectDir + '/' : 'bmad/';
+
+    // Common replacements (including in the activation block)
+    processed = processed.replaceAll('{project-root}', projectRoot);
+    processed = processed.replaceAll('{module}', metadata.module || 'core');
+    processed = processed.replaceAll('{agent}', metadata.name || '');
+    processed = processed.replaceAll('{task}', metadata.name || '');
+
+    return processed;
+  }
+
+  /**
+   * Ensure directory exists
+   * @param {string} dirPath - Directory path
+   */
+  async ensureDir(dirPath) {
+    await fs.ensureDir(dirPath);
+  }
+
+  /**
+   * Write file with content
+   * @param {string} filePath - File path
+   * @param {string} content - File content
+   */
+  async writeFile(filePath, content) {
+    await this.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  /**
+   * Copy file from source to destination
+   * @param {string} source - Source file path
+   * @param {string} dest - Destination file path
+   */
+  async copyFile(source, dest) {
+    await this.ensureDir(path.dirname(dest));
+    await fs.copy(source, dest, { overwrite: true });
+  }
+
+  /**
+   * Check if path exists
+   * @param {string} pathToCheck - Path to check
+   * @returns {boolean} True if path exists
+   */
+  async exists(pathToCheck) {
+    return await fs.pathExists(pathToCheck);
+  }
+
+  /**
+   * Alias for exists method
+   * @param {string} pathToCheck - Path to check
+   * @returns {boolean} True if path exists
+   */
+  async pathExists(pathToCheck) {
+    return await fs.pathExists(pathToCheck);
+  }
+
+  /**
+   * Read file content
+   * @param {string} filePath - File path
+   * @returns {string} File content
+   */
+  async readFile(filePath) {
+    return await fs.readFile(filePath, 'utf8');
+  }
+
+  /**
+   * Format name as title
+   * @param {string} name - Name to format
+   * @returns {string} Formatted title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Create agent configuration file
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} agent - Agent information
+   */
+  async createAgentConfig(bmadDir, agent) {
+    const agentConfigDir = path.join(bmadDir, '_cfg', 'agents');
+    await this.ensureDir(agentConfigDir);
+
+    // Load agent config template
+    const templatePath = getSourcePath('utility', 'models', 'agent-config-template.md');
+    const templateContent = await this.readFile(templatePath);
+
+    const configContent = `# Agent Config: ${agent.name}
+
+${templateContent}`;
+
+    const configPath = path.join(agentConfigDir, `${agent.module}-${agent.name}.md`);
+    await this.writeFile(configPath, configContent);
+  }
+}
+
+module.exports = { BaseIdeSetup };

package/tools/cli/installers/lib/ide/auggie.js

@@ -0,0 +1,271 @@
+const path = require('node:path');
+const os = require('node:os');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+/**
+ * Auggie CLI setup handler
+ * Allows flexible installation of agents to multiple locations
+ */
+class AuggieSetup extends BaseIdeSetup {
+  constructor() {
+    super('auggie', 'Auggie CLI');
+    this.defaultLocations = [
+      { name: 'Project Directory (.auggie/commands)', value: '.auggie/commands', checked: true },
+      { name: 'User Home (~/.auggie/commands)', value: path.join(os.homedir(), '.auggie', 'commands') },
+      { name: 'Custom Location', value: 'custom' },
+    ];
+  }
+
+  /**
+   * Collect configuration choices before installation
+   * @param {Object} options - Configuration options
+   * @returns {Object} Collected configuration
+   */
+  async collectConfiguration(options = {}) {
+    const response = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'locations',
+        message: 'Select Auggie CLI installation locations:',
+        choices: this.defaultLocations,
+        validate: (answers) => {
+          if (answers.length === 0) {
+            return 'Please select at least one location';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    const locations = [];
+    for (const loc of response.locations) {
+      if (loc === 'custom') {
+        const custom = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'path',
+            message: 'Enter custom path for Auggie commands:',
+            validate: (input) => {
+              if (!input.trim()) {
+                return 'Path cannot be empty';
+              }
+              return true;
+            },
+          },
+        ]);
+        locations.push(custom.path);
+      } else {
+        locations.push(loc);
+      }
+    }
+
+    return { auggieLocations: locations };
+  }
+
+  /**
+   * Setup Auggie CLI configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} bmadDir - BMAD installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, bmadDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Use pre-collected configuration if available
+    const config = options.preCollectedConfig || {};
+    const locations = await this.getInstallLocations(projectDir, { ...options, auggieLocations: config.auggieLocations });
+
+    if (locations.length === 0) {
+      console.log(chalk.yellow('No locations selected. Skipping Auggie CLI setup.'));
+      return { success: false, reason: 'no-locations' };
+    }
+
+    // Get agents and tasks
+    const agents = await this.getAgents(bmadDir);
+    const tasks = await this.getTasks(bmadDir);
+
+    let totalInstalled = 0;
+
+    // Install to each selected location
+    for (const location of locations) {
+      console.log(chalk.dim(`\n  Installing to: ${location}`));
+
+      const agentsDir = path.join(location, 'agents');
+      const tasksDir = path.join(location, 'tasks');
+
+      await this.ensureDir(agentsDir);
+      await this.ensureDir(tasksDir);
+
+      // Install agents
+      for (const agent of agents) {
+        const content = await this.readFile(agent.path);
+        const commandContent = this.createAgentCommand(agent, content);
+
+        const targetPath = path.join(agentsDir, `${agent.module}-${agent.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        totalInstalled++;
+      }
+
+      // Install tasks
+      for (const task of tasks) {
+        const content = await this.readFile(task.path);
+        const commandContent = this.createTaskCommand(task, content);
+
+        const targetPath = path.join(tasksDir, `${task.module}-${task.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        totalInstalled++;
+      }
+
+      console.log(chalk.green(`  ✓ Installed ${agents.length} agents and ${tasks.length} tasks`));
+    }
+
+    console.log(chalk.green(`\n✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${totalInstalled} total commands installed`));
+    console.log(chalk.dim(`  - ${locations.length} location(s) configured`));
+
+    return {
+      success: true,
+      commands: totalInstalled,
+      locations: locations.length,
+    };
+  }
+
+  /**
+   * Get installation locations from user
+   */
+  async getInstallLocations(projectDir, options) {
+    if (options.auggieLocations) {
+      // Process the pre-collected locations to resolve relative paths
+      const processedLocations = [];
+      for (const loc of options.auggieLocations) {
+        if (loc === '.auggie/commands') {
+          // Relative to project directory
+          processedLocations.push(path.join(projectDir, loc));
+        } else {
+          processedLocations.push(loc);
+        }
+      }
+      return processedLocations;
+    }
+
+    const response = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'locations',
+        message: 'Select Auggie CLI installation locations:',
+        choices: this.defaultLocations,
+        validate: (answers) => {
+          if (answers.length === 0) {
+            return 'Please select at least one location';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    const locations = [];
+    for (const loc of response.locations) {
+      if (loc === 'custom') {
+        const custom = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'path',
+            message: 'Enter custom path for Auggie commands:',
+            validate: (input) => {
+              if (!input.trim()) {
+                return 'Path cannot be empty';
+              }
+              return true;
+            },
+          },
+        ]);
+        locations.push(custom.path);
+      } else if (loc.startsWith('.auggie')) {
+        // Relative to project directory
+        locations.push(path.join(projectDir, loc));
+      } else {
+        locations.push(loc);
+      }
+    }
+
+    return locations;
+  }
+
+  /**
+   * Create agent command content
+   */
+  createAgentCommand(agent, content) {
+    const titleMatch = content.match(/title="([^"]+)"/);
+    const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
+
+    return `# ${title} Agent
+
+## Activation
+Type \`@${agent.name}\` to activate this agent.
+
+${content}
+
+## Module
+BMAD ${agent.module.toUpperCase()} module
+`;
+  }
+
+  /**
+   * Create task command content
+   */
+  createTaskCommand(task, content) {
+    const nameMatch = content.match(/<name>([^<]+)<\/name>/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    return `# ${taskName} Task
+
+## Activation
+Type \`@task-${task.name}\` to execute this task.
+
+${content}
+
+## Module
+BMAD ${task.module.toUpperCase()} module
+`;
+  }
+
+  /**
+   * Cleanup Auggie configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+
+    // Check common locations
+    const locations = [path.join(os.homedir(), '.auggie', 'commands'), path.join(projectDir, '.auggie', 'commands')];
+
+    for (const location of locations) {
+      const agentsDir = path.join(location, 'agents');
+      const tasksDir = path.join(location, 'tasks');
+
+      if (await fs.pathExists(agentsDir)) {
+        // Remove only BMAD files (those with module prefix)
+        const files = await fs.readdir(agentsDir);
+        for (const file of files) {
+          if (file.includes('-') && file.endsWith('.md')) {
+            await fs.remove(path.join(agentsDir, file));
+          }
+        }
+      }
+
+      if (await fs.pathExists(tasksDir)) {
+        const files = await fs.readdir(tasksDir);
+        for (const file of files) {
+          if (file.includes('-') && file.endsWith('.md')) {
+            await fs.remove(path.join(tasksDir, file));
+          }
+        }
+      }
+    }
+
+    console.log(chalk.dim('Cleaned up Auggie CLI configurations'));
+  }
+}
+
+module.exports = { AuggieSetup };