whiteport-design-studio 0.2.2 → 0.3.0

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

@@ -0,0 +1,116 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * Cursor IDE setup handler for WDS
+ */
+class CursorSetup extends BaseIdeSetup {
+  constructor() {
+    super('cursor', 'Cursor', true); // preferred IDE
+    this.configDir = '.cursor/rules/wds';
+  }
+
+  /**
+   * Setup Cursor IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} wdsDir - WDS installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, wdsDir, options = {}) {
+    // Create .cursor/rules/wds directory
+    const targetDir = path.join(projectDir, this.configDir);
+    await this.ensureDir(targetDir);
+
+    // Get all WDS agents
+    const agents = await this.getAgents(wdsDir);
+
+    if (agents.length === 0) {
+      throw new Error('No agents found in WDS installation');
+    }
+
+    // Create launcher file for each agent
+    let agentCount = 0;
+    for (const agent of agents) {
+      // Create launcher content that references the compiled agent
+      const launcher = this.formatAgentLauncher(agent.name, agent.path);
+
+      // Add Cursor-specific MDC frontmatter
+      const content = this.processContent(launcher, agent.metadata);
+
+      // Write launcher file with .mdc extension
+      const filePath = path.join(targetDir, `${agent.slug}.mdc`);
+      await this.writeFile(filePath, content);
+      agentCount++;
+    }
+
+    if (options.logger) {
+      options.logger.log(chalk.dim(`    - ${agentCount} agent(s) configured for Cursor`));
+    }
+
+    return {
+      success: true,
+      agents: agentCount,
+    };
+  }
+
+  /**
+   * Process content with Cursor-specific MDC frontmatter
+   * @param {string} content - Launcher content
+   * @param {Object} metadata - Agent metadata
+   * @returns {string} Processed content with Cursor MDC frontmatter
+   */
+  processContent(content, metadata = {}) {
+    // Strip any existing frontmatter from launcher
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = content.replace(frontmatterRegex, '');
+
+    const description = metadata.name
+      ? `WDS Agent: ${metadata.name} - ${metadata.description}`
+      : `WDS Agent: ${metadata.description || 'Agent'}`;
+
+    // Create Cursor MDC metadata header
+    const mdcHeader = `---
+description: ${description}
+globs:
+alwaysApply: false
+---
+
+`;
+
+    return mdcHeader + contentWithoutFrontmatter;
+  }
+
+  /**
+   * Cleanup Cursor WDS configuration
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const wdsPath = path.join(projectDir, this.configDir);
+
+    if (await this.exists(wdsPath)) {
+      await this.remove(wdsPath);
+      console.log(chalk.dim(`Removed Cursor WDS configuration`));
+    }
+  }
+
+  /**
+   * Detect if Cursor is configured in project
+   * @param {string} projectDir - Project directory
+   * @returns {boolean}
+   */
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, '.cursor'));
+  }
+
+  /**
+   * Remove directory helper
+   * @param {string} dirPath - Directory to remove
+   */
+  async remove(dirPath) {
+    const fs = require('fs-extra');
+    await fs.remove(dirPath);
+  }
+}
+
+module.exports = { CursorSetup };

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

@@ -0,0 +1,50 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+
+/**
+ * Gemini CLI setup handler for WDS
+ * Uses TOML format for commands
+ */
+class GeminiSetup extends BaseIdeSetup {
+  constructor() {
+    super('gemini', 'Gemini CLI', false);
+    this.configDir = '.gemini/commands/wds';
+  }
+
+  async setup(projectDir, wdsDir, options = {}) {
+    const targetDir = path.join(projectDir, this.configDir);
+    await this.ensureDir(targetDir);
+
+    const agents = await this.getAgents(wdsDir);
+    if (agents.length === 0) throw new Error('No agents found in WDS installation');
+
+    for (const agent of agents) {
+      const launcher = this.formatAgentLauncher(agent.name, agent.path);
+      const content = this.processContent(launcher, agent.metadata);
+      await this.writeFile(path.join(targetDir, `${agent.slug}.toml`), content);
+    }
+
+    return { success: true, agents: agents.length };
+  }
+
+  processContent(content, metadata = {}) {
+    const description = metadata.name ? `${metadata.name} - ${metadata.description}` : metadata.description || 'WDS Agent';
+
+    // Escape content for TOML multi-line string
+    const escapedContent = content.replaceAll('"""', String.raw`\"\"\"`);
+
+    return `description = "${description}"
+
+[prompt]
+text = """
+${escapedContent}
+"""
+`;
+  }
+
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, '.gemini'));
+  }
+}
+
+module.exports = { GeminiSetup };

package/tools/cli/installers/lib/ide/github-copilot.js

@@ -0,0 +1,106 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+
+/**
+ * GitHub Copilot IDE setup handler for WDS
+ * Note: GitHub Copilot doesn't support includes/references, so we must copy full agent content
+ */
+class GitHubCopilotSetup extends BaseIdeSetup {
+  constructor() {
+    super('github-copilot', 'GitHub Copilot', false);
+    this.configFile = '.github/copilot-instructions.md';
+  }
+
+  /**
+   * Setup GitHub Copilot IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} wdsDir - WDS installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, wdsDir, options = {}) {
+    // Ensure .github directory exists
+    const githubDir = path.join(projectDir, '.github');
+    await this.ensureDir(githubDir);
+
+    // Get all WDS agents
+    const agents = await this.getAgents(wdsDir);
+
+    if (agents.length === 0) {
+      throw new Error('No agents found in WDS installation');
+    }
+
+    // Build content to append
+    let content = '\n\n## WDS Agents\n\n';
+    content += '<!-- Generated by WDS installer - Do not edit manually -->\n\n';
+
+    // For each agent, read the full compiled agent content
+    let agentCount = 0;
+    for (const agent of agents) {
+      // Read the full agent content
+      const agentContent = await this.readFile(agent.path);
+
+      // Add section header
+      content += `### ${agent.metadata.name} - ${agent.metadata.description}\n\n`;
+
+      // Add full agent content
+      content += agentContent + '\n\n';
+      content += '---\n\n';
+
+      agentCount++;
+    }
+
+    // Append to copilot-instructions.md
+    const filePath = path.join(projectDir, this.configFile);
+
+    if (await this.exists(filePath)) {
+      // File exists, append to it
+      const fs = require('fs-extra');
+      await fs.appendFile(filePath, content);
+    } else {
+      // File doesn't exist, create it
+      await this.writeFile(filePath, content);
+    }
+
+    if (options.logger) {
+      options.logger.log(chalk.dim(`    - ${agentCount} agent(s) configured for GitHub Copilot`));
+    }
+
+    return {
+      success: true,
+      agents: agentCount,
+    };
+  }
+
+  /**
+   * Cleanup GitHub Copilot WDS configuration
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const filePath = path.join(projectDir, this.configFile);
+
+    if (await this.exists(filePath)) {
+      // Read file, remove WDS Agents section
+      const fs = require('fs-extra');
+      const content = await fs.readFile(filePath, 'utf8');
+
+      // Remove WDS Agents section (everything from "## WDS Agents" to the end or next ## section)
+      const wdsAgentsRegex = /\n\n## WDS Agents\n\n[\s\S]*?(?=\n\n##\s|$)/;
+      const cleanedContent = content.replace(wdsAgentsRegex, '');
+
+      await fs.writeFile(filePath, cleanedContent);
+      console.log(chalk.dim(`Removed GitHub Copilot WDS configuration`));
+    }
+  }
+
+  /**
+   * Detect if GitHub Copilot is configured in project
+   * @param {string} projectDir - Project directory
+   * @returns {boolean}
+   */
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, '.github'));
+  }
+}
+
+module.exports = { GitHubCopilotSetup };

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

@@ -0,0 +1,42 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+
+/**
+ * iFlow CLI setup handler for WDS
+ */
+class IFlowSetup extends BaseIdeSetup {
+  constructor() {
+    super('iflow', 'iFlow CLI', false);
+    this.configDir = '.iflow/commands/wds';
+  }
+
+  async setup(projectDir, wdsDir, options = {}) {
+    const targetDir = path.join(projectDir, this.configDir);
+    await this.ensureDir(targetDir);
+
+    const agents = await this.getAgents(wdsDir);
+    if (agents.length === 0) throw new Error('No agents found in WDS installation');
+
+    for (const agent of agents) {
+      const launcher = this.formatAgentLauncher(agent.name, agent.path);
+      const content = this.processContent(launcher, agent.metadata);
+      await this.writeFile(path.join(targetDir, `${agent.slug}.md`), content);
+    }
+
+    return { success: true, agents: agents.length };
+  }
+
+  processContent(content, metadata = {}) {
+    const title = metadata.name ? `${metadata.name} - ${metadata.description}` : metadata.description || 'WDS Agent';
+
+    return `# ${title}
+
+${content}`;
+  }
+
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, '.iflow'));
+  }
+}
+
+module.exports = { IFlowSetup };

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

@@ -0,0 +1,55 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const { BaseIdeSetup } = require('./_base-ide');
+
+/**
+ * Kilo Code setup handler for WDS
+ * Appends agent modes to .kilocodemodes YAML file
+ */
+class KiloSetup extends BaseIdeSetup {
+  constructor() {
+    super('kilo', 'Kilo Code', false);
+    this.configFile = '.kilocodemodes';
+  }
+
+  async setup(projectDir, wdsDir, options = {}) {
+    const agents = await this.getAgents(wdsDir);
+    if (agents.length === 0) throw new Error('No agents found in WDS installation');
+
+    const filePath = path.join(projectDir, this.configFile);
+
+    // Build modes content
+    let modesContent = '\n# WDS Agent Modes\n';
+
+    for (const agent of agents) {
+      const launcher = this.formatAgentLauncher(agent.name, agent.path);
+
+      modesContent += `\n- slug: wds-${agent.slug}`;
+      modesContent += `\n  name: "${agent.metadata.name || agent.slug}"`;
+      modesContent += `\n  roleDefinition: "${agent.metadata.description || 'WDS Agent'}"`;
+      modesContent += `\n  customInstructions: |`;
+      // Indent launcher content for YAML block
+      const indented = launcher
+        .split('\n')
+        .map((line) => `    ${line}`)
+        .join('\n');
+      modesContent += `\n${indented}\n`;
+    }
+
+    if (await this.exists(filePath)) {
+      // Append to existing file
+      await fs.appendFile(filePath, modesContent);
+    } else {
+      // Create new file
+      await this.writeFile(filePath, modesContent);
+    }
+
+    return { success: true, agents: agents.length };
+  }
+
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, this.configFile));
+  }
+}
+
+module.exports = { KiloSetup };

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

@@ -0,0 +1,44 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+
+/**
+ * Kiro CLI setup handler for WDS
+ * Creates JSON config + markdown prompt files
+ */
+class KiroCliSetup extends BaseIdeSetup {
+  constructor() {
+    super('kiro-cli', 'Kiro CLI', false);
+    this.configDir = '.kiro/agents/wds';
+  }
+
+  async setup(projectDir, wdsDir, options = {}) {
+    const targetDir = path.join(projectDir, this.configDir);
+    await this.ensureDir(targetDir);
+
+    const agents = await this.getAgents(wdsDir);
+    if (agents.length === 0) throw new Error('No agents found in WDS installation');
+
+    for (const agent of agents) {
+      const launcher = this.formatAgentLauncher(agent.name, agent.path);
+
+      // Write JSON config
+      const jsonConfig = {
+        name: agent.metadata.name || agent.slug,
+        description: agent.metadata.description || 'WDS Agent',
+        prompt: `./${agent.slug}-prompt.md`,
+      };
+      await this.writeFile(path.join(targetDir, `${agent.slug}.json`), JSON.stringify(jsonConfig, null, 2));
+
+      // Write markdown prompt
+      await this.writeFile(path.join(targetDir, `${agent.slug}-prompt.md`), launcher);
+    }
+
+    return { success: true, agents: agents.length };
+  }
+
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, '.kiro'));
+  }
+}
+
+module.exports = { KiroCliSetup };

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

@@ -0,0 +1,218 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+
+/**
+ * IDE Manager - handles IDE-specific setup for WDS
+ * Dynamically discovers and loads IDE handlers
+ */
+class IdeManager {
+  constructor() {
+    this.handlers = new Map();
+    this.loadHandlers();
+    this.wdsFolderName = '_bmad/wds'; // Default, can be overridden
+  }
+
+  /**
+   * Set the WDS folder name for all IDE handlers
+   * @param {string} wdsFolderName - The WDS folder name
+   */
+  setWdsFolderName(wdsFolderName) {
+    this.wdsFolderName = wdsFolderName;
+    // Update all loaded handlers
+    for (const handler of this.handlers.values()) {
+      if (typeof handler.setWdsFolderName === 'function') {
+        handler.setWdsFolderName(wdsFolderName);
+      }
+    }
+  }
+
+  /**
+   * Dynamically load all IDE handlers from directory
+   */
+  loadHandlers() {
+    const ideDir = __dirname;
+
+    try {
+      // Get all JS files in the IDE directory
+      const files = fs.readdirSync(ideDir).filter((file) => {
+        // Skip base class, manager, and utility files (starting with _)
+        return file.endsWith('.js') && !file.startsWith('_') && file !== 'manager.js';
+      });
+
+      // Sort alphabetically for consistent ordering
+      files.sort();
+
+      for (const file of files) {
+        const moduleName = path.basename(file, '.js');
+
+        try {
+          const modulePath = path.join(ideDir, file);
+          const HandlerModule = require(modulePath);
+
+          // Get the first exported class (handles various export styles)
+          const HandlerClass = HandlerModule.default || HandlerModule[Object.keys(HandlerModule)[0]];
+
+          if (HandlerClass) {
+            const instance = new HandlerClass();
+            // Use the name property from the instance (set in constructor)
+            // Only add if the instance has a valid name
+            if (instance.name && typeof instance.name === 'string') {
+              this.handlers.set(instance.name, instance);
+            } else {
+              console.log(chalk.yellow(`  Warning: ${moduleName} handler missing valid 'name' property`));
+            }
+          }
+        } catch (error) {
+          console.log(chalk.yellow(`  Warning: Could not load ${moduleName}: ${error.message}`));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to load IDE handlers:'), error.message);
+    }
+  }
+
+  /**
+   * Get all available IDEs with their metadata
+   * @returns {Array} Array of IDE information objects
+   */
+  getAvailableIdes() {
+    const ides = [];
+
+    for (const [key, handler] of this.handlers) {
+      // Skip handlers without valid names
+      const name = handler.displayName || handler.name || key;
+
+      // Filter out invalid entries
+      if (!key || !name || typeof key !== 'string' || typeof name !== 'string') {
+        continue;
+      }
+
+      ides.push({
+        value: key,
+        name: name,
+        preferred: handler.preferred || false,
+      });
+    }
+
+    // Sort: preferred first, then alphabetical
+    ides.sort((a, b) => {
+      if (a.preferred && !b.preferred) return -1;
+      if (!a.preferred && b.preferred) return 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return ides;
+  }
+
+  /**
+   * Setup IDE integrations for selected IDEs
+   * Main method called by installer
+   * @param {string} projectDir - Project directory
+   * @param {string} wdsDir - WDS installation directory
+   * @param {Array<string>} selectedIdes - List of IDE names to setup
+   * @param {Object} options - Setup options (logger, etc.)
+   * @returns {Object} Results object with success/failure counts
+   */
+  async setup(projectDir, wdsDir, selectedIdes, options = {}) {
+    const results = {
+      success: [],
+      failed: [],
+      skipped: [],
+    };
+
+    const logger = options.logger || console;
+
+    // Set WDS folder name if provided
+    if (options.wdsFolderName) {
+      this.setWdsFolderName(options.wdsFolderName);
+    }
+
+    for (const ideName of selectedIdes) {
+      const handler = this.handlers.get(ideName.toLowerCase());
+
+      if (!handler) {
+        logger.warn(chalk.yellow(`  ⚠ IDE '${ideName}' is not yet supported`));
+        results.skipped.push({ ide: ideName, reason: 'unsupported' });
+        continue;
+      }
+
+      try {
+        logger.log(chalk.dim(`  Setting up ${handler.displayName || ideName}...`));
+        await handler.setup(projectDir, wdsDir, options);
+        results.success.push(ideName);
+        logger.log(chalk.green(`  ✓ ${handler.displayName || ideName} configured`));
+      } catch (error) {
+        logger.warn(chalk.yellow(`  ⚠ Failed to setup ${ideName}: ${error.message}`));
+        results.failed.push({ ide: ideName, error: error.message });
+      }
+    }
+
+    // Log summary
+    if (results.success.length > 0) {
+      logger.log(chalk.dim(`  Configured ${results.success.length} IDE(s)`));
+    }
+
+    if (results.failed.length > 0) {
+      logger.warn(chalk.yellow(`  ${results.failed.length} IDE(s) failed to configure`));
+    }
+
+    return results;
+  }
+
+  /**
+   * Cleanup IDE configurations
+   * @param {string} projectDir - Project directory
+   * @returns {Array} Results for each IDE
+   */
+  async cleanup(projectDir) {
+    const results = [];
+
+    for (const [name, handler] of this.handlers) {
+      try {
+        await handler.cleanup(projectDir);
+        results.push({ ide: name, success: true });
+      } catch (error) {
+        results.push({ ide: name, success: false, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Get list of supported IDEs
+   * @returns {Array} List of supported IDE names
+   */
+  getSupportedIdes() {
+    return [...this.handlers.keys()];
+  }
+
+  /**
+   * Check if an IDE is supported
+   * @param {string} ideName - Name of the IDE
+   * @returns {boolean} True if IDE is supported
+   */
+  isSupported(ideName) {
+    return this.handlers.has(ideName.toLowerCase());
+  }
+
+  /**
+   * Detect installed IDEs in project
+   * @param {string} projectDir - Project directory
+   * @returns {Array} List of detected IDEs
+   */
+  async detectInstalledIdes(projectDir) {
+    const detected = [];
+
+    for (const [name, handler] of this.handlers) {
+      if (typeof handler.detect === 'function' && (await handler.detect(projectDir))) {
+        detected.push(name);
+      }
+    }
+
+    return detected;
+  }
+}
+
+module.exports = { IdeManager };

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

@@ -0,0 +1,44 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+
+/**
+ * OpenCode IDE setup handler for WDS
+ */
+class OpenCodeSetup extends BaseIdeSetup {
+  constructor() {
+    super('opencode', 'OpenCode', false);
+    this.configDir = '.opencode/agent/wds';
+  }
+
+  async setup(projectDir, wdsDir, options = {}) {
+    const targetDir = path.join(projectDir, this.configDir);
+    await this.ensureDir(targetDir);
+
+    const agents = await this.getAgents(wdsDir);
+    if (agents.length === 0) throw new Error('No agents found in WDS installation');
+
+    for (const agent of agents) {
+      const launcher = this.formatAgentLauncher(agent.name, agent.path);
+      const content = this.processContent(launcher, agent.metadata);
+      await this.writeFile(path.join(targetDir, `${agent.slug}.md`), content);
+    }
+
+    return { success: true, agents: agents.length };
+  }
+
+  processContent(content, metadata = {}) {
+    return `---
+name: ${metadata.name || 'WDS Agent'}
+description: ${metadata.description || 'Agent'}
+mode: agent
+---
+
+${content}`;
+  }
+
+  async detect(projectDir) {
+    return await this.exists(path.join(projectDir, '.opencode'));
+  }
+}
+
+module.exports = { OpenCodeSetup };