bmad-stella 1.0.0

package/tools/installer/config/install.config.yaml

@@ -0,0 +1,184 @@
+installation-options:
+  full:
+    name: Complete BMad Core
+    description: Copy the entire .bmad-core folder with all agents, templates, and tools
+    action: copy-folder
+    source: bmad-core
+  single-agent:
+    name: Single Agent
+    description: Select and install a single agent with its dependencies
+    action: copy-agent
+ide-configurations:
+  cursor:
+    name: Cursor
+    rule-dir: .cursor/rules/bmad/
+    format: multi-file
+    command-suffix: .mdc
+    instructions: |
+      # To use BMad agents in Cursor:
+      # 1. Press Ctrl+L (Cmd+L on Mac) to open the chat
+      # 2. Type @agent-name (e.g., "@dev", "@pm", "@architect")
+      # 3. The agent will adopt that persona for the conversation
+  claude-code:
+    name: Claude Code
+    rule-dir: .claude/commands/BMad/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Claude Code:
+      # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
+      # 2. Claude will switch to that agent's persona
+  iflow-cli:
+    name: iFlow CLI
+    rule-dir: .iflow/commands/BMad/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in iFlow CLI:
+      # 1. Type /agent-name (e.g., "/dev", "/pm", "/architect")
+      # 2. iFlow will switch to that agent's persona
+  crush:
+    name: Crush
+    rule-dir: .crush/commands/BMad/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Crush:
+      # 1. Press CTRL + P and press TAB
+      # 2. Select agent or task
+      # 3. Crush will switch to that agent's persona / task
+  windsurf:
+    name: Windsurf
+    rule-dir: .windsurf/workflows/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Windsurf:
+      # 1. Type /agent-name (e.g., "/dev", "/pm")
+      # 2. Windsurf will adopt that agent's persona
+  trae:
+    name: Trae
+    rule-dir: .trae/rules/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Trae:
+      # 1. Type @agent-name (e.g., "@dev", "@pm", "@architect")
+      # 2. Trae will adopt that agent's persona
+  roo:
+    name: Roo Code
+    format: custom-modes
+    file: .roomodes
+    instructions: |
+      # To use BMad agents in Roo Code:
+      # 1. Open the mode selector (usually in the status bar)
+      # 2. Select any bmad-{agent} mode (e.g., "bmad-dev", "bmad-pm")
+      # 3. The AI will adopt that agent's full personality and capabilities
+  cline:
+    name: Cline
+    rule-dir: .clinerules/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Cline:
+      # 1. Open the Cline chat panel in VS Code
+      # 2. Type @agent-name (e.g., "@dev", "@pm", "@architect")
+      # 3. The agent will adopt that persona for the conversation
+      # 4. Rules are stored in .clinerules/ directory in your project
+  gemini:
+    name: Gemini CLI
+    rule-dir: .gemini/commands/BMad/
+    format: multi-file
+    command-suffix: .toml
+    instructions: |
+      # To use BMad agents with the Gemini CLI:
+      # 1. The installer creates a `BMad` folder in `.gemini/commands`.
+      # 2. This adds custom commands for each agent and task.
+      # 3. Type /BMad:agents:<agent-name> (e.g., "/BMad:agents:dev", "/BMad:agents:pm") or /BMad:tasks:<task-name> (e.g., "/BMad:tasks:create-doc").
+      # 4. The agent will adopt that persona for the conversation or preform the task.
+  github-copilot:
+    name: Github Copilot
+    rule-dir: .github/chatmodes/
+    format: multi-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents with Github Copilot:
+      # 1. The installer creates a .github/chatmodes/ directory in your project
+      # 2. Open the Chat view (`⌃⌘I` on Mac, `Ctrl+Alt+I` on Windows/Linux) and select **Agent** from the chat mode selector.
+      # 3. The agent will adopt that persona for the conversation
+      # 4. Requires VS Code 1.101+ with `chat.agent.enabled: true` in settings
+      # 5. Agent files are stored in .github/chatmodes/
+      # 6. Use `*help` to see available commands and agents
+  kilo:
+    name: Kilo Code
+    format: custom-modes
+    file: .kilocodemodes
+    instructions: |
+      # To use BMAD™ agents in Kilo Code:
+      # 1. Open the mode selector in VSCode
+      # 2. Select a bmad-{agent} mode (e.g. "bmad-dev")
+      # 3. The AI adopts that agent's persona and capabilities
+
+  qwen-code:
+    name: Qwen Code
+    rule-dir: .qwen/bmad-method/
+    format: single-file
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents with Qwen Code:
+      # 1. The installer creates a .qwen/bmad-method/ directory in your project.
+      # 2. It concatenates all agent files into a single QWEN.md file.
+      # 3. Simply mention the agent in your prompt (e.g., "As *dev, ...").
+      # 4. The Qwen Code CLI will automatically have the context for that agent.
+
+  auggie-cli:
+    name: Auggie CLI (Augment Code)
+    format: multi-location
+    locations:
+      user:
+        name: User Commands (Global)
+        rule-dir: ~/.augment/commands/bmad/
+        description: Available across all your projects (user-wide)
+      workspace:
+        name: Workspace Commands (Project)
+        rule-dir: ./.augment/commands/bmad/
+        description: Stored in your repository and shared with your team
+    command-suffix: .md
+    instructions: |
+      # To use BMad agents in Auggie CLI (Augment Code):
+      # 1. Type /bmad:agent-name (e.g., "/bmad:dev", "/bmad:pm", "/bmad:architect")
+      # 2. The agent will adopt that persona for the conversation
+      # 3. Commands are available based on your selected location(s)
+
+  codex:
+    name: Codex CLI
+    format: project-memory
+    file: AGENTS.md
+    instructions: |
+      # To use BMAD agents with Codex CLI:
+      # 1. The installer updates/creates AGENTS.md at your project root with BMAD agents and tasks.
+      # 2. Run `codex` in your project. Codex automatically reads AGENTS.md as project memory.
+      # 3. Mention agents in your prompt (e.g., "As dev, please implement ...") or reference tasks.
+      # 4. You can further customize global Codex behavior via ~/.codex/config.toml.
+
+  codex-web:
+    name: Codex Web Enabled
+    format: project-memory
+    file: AGENTS.md
+    instructions: |
+      # To enable BMAD agents for Codex Web (cloud):
+      # 1. The installer updates/creates AGENTS.md and ensures `.bmad-core` is NOT ignored by git.
+      # 2. Commit `.bmad-core/` and `AGENTS.md` to your repository.
+      # 3. Open the repo in Codex Web and reference agents naturally (e.g., "As dev, ...").
+      # 4. Re-run this installer to refresh agent sections when the core changes.
+
+  opencode:
+    name: OpenCode CLI
+    format: jsonc-config
+    file: opencode.jsonc
+    instructions: |
+      # To use BMAD agents with OpenCode CLI:
+      # 1. The installer creates/updates `opencode.jsonc` at your project root.
+      # 2. It ensures the BMAD core instructions file is referenced: `./.bmad-core/core-config.yaml`.
+      # 3. If an existing `opencode.json` or `opencode.jsonc` is present, it is preserved and only `instructions` are minimally merged.
+      # 4. Run `opencode` in this project to use your configured agents and commands.

package/tools/installer/lib/config-loader.js

@@ -0,0 +1,257 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const yaml = require('js-yaml');
+const { extractYamlFromAgent } = require('../../lib/yaml-utils');
+
+class ConfigLoader {
+  constructor() {
+    this.configPath = path.join(__dirname, '..', 'config', 'install.config.yaml');
+    this.config = null;
+  }
+
+  async load() {
+    if (this.config) return this.config;
+
+    try {
+      const configContent = await fs.readFile(this.configPath, 'utf8');
+      this.config = yaml.load(configContent);
+      return this.config;
+    } catch (error) {
+      throw new Error(`Failed to load configuration: ${error.message}`);
+    }
+  }
+
+  async getInstallationOptions() {
+    const config = await this.load();
+    return config['installation-options'] || {};
+  }
+
+  async getAvailableAgents() {
+    const agentsDir = path.join(this.getBmadCorePath(), 'agents');
+
+    try {
+      const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+      const agents = [];
+
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+          const agentPath = path.join(agentsDir, entry.name);
+          const agentId = path.basename(entry.name, '.md');
+
+          try {
+            const agentContent = await fs.readFile(agentPath, 'utf8');
+
+            // Extract YAML block from agent file
+            const yamlContentText = extractYamlFromAgent(agentContent);
+            if (yamlContentText) {
+              const yamlContent = yaml.load(yamlContentText);
+              const agentConfig = yamlContent.agent || {};
+
+              agents.push({
+                id: agentId,
+                name: agentConfig.title || agentConfig.name || agentId,
+                file: `bmad-core/agents/${entry.name}`,
+                description: agentConfig.whenToUse || 'No description available',
+              });
+            }
+          } catch (error) {
+            console.warn(`Failed to read agent ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+
+      // Sort agents by name for consistent display
+      agents.sort((a, b) => a.name.localeCompare(b.name));
+
+      return agents;
+    } catch (error) {
+      console.warn(`Failed to read agents directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  async getAvailableExpansionPacks() {
+    const expansionPacksDir = path.join(this.getBmadCorePath(), '..', 'expansion-packs');
+
+    try {
+      const entries = await fs.readdir(expansionPacksDir, { withFileTypes: true });
+      const expansionPacks = [];
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && !entry.name.startsWith('.')) {
+          const packPath = path.join(expansionPacksDir, entry.name);
+          const configPath = path.join(packPath, 'config.yaml');
+
+          try {
+            // Read config.yaml
+            const configContent = await fs.readFile(configPath, 'utf8');
+            const config = yaml.load(configContent);
+
+            expansionPacks.push({
+              id: entry.name,
+              name: config.name || entry.name,
+              description:
+                config['short-title'] || config.description || 'No description available',
+              fullDescription:
+                config.description || config['short-title'] || 'No description available',
+              version: config.version || '1.0.0',
+              author: config.author || 'BMad Team',
+              packPath: packPath,
+              dependencies: config.dependencies?.agents || [],
+            });
+          } catch (error) {
+            // Fallback if config.yaml doesn't exist or can't be read
+            console.warn(
+              `Failed to read config for expansion pack ${entry.name}: ${error.message}`,
+            );
+
+            // Try to derive info from directory name as fallback
+            const name = entry.name
+              .split('-')
+              .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+              .join(' ');
+
+            expansionPacks.push({
+              id: entry.name,
+              name: name,
+              description: 'No description available',
+              fullDescription: 'No description available',
+              version: '1.0.0',
+              author: 'BMad Team',
+              packPath: packPath,
+              dependencies: [],
+            });
+          }
+        }
+      }
+
+      return expansionPacks;
+    } catch (error) {
+      console.warn(`Failed to read expansion packs directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  async getAgentDependencies(agentId) {
+    // Use DependencyResolver to dynamically parse agent dependencies
+    const DependencyResolver = require('../../lib/dependency-resolver');
+    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
+
+    const agentDeps = await resolver.resolveAgentDependencies(agentId);
+
+    // Convert to flat list of file paths
+    const depPaths = [];
+
+    // Core files and utilities are included automatically by DependencyResolver
+
+    // Add agent file itself is already handled by installer
+
+    // Add all resolved resources
+    for (const resource of agentDeps.resources) {
+      const filePath = `.bmad-core/${resource.type}/${resource.id}.md`;
+      if (!depPaths.includes(filePath)) {
+        depPaths.push(filePath);
+      }
+    }
+
+    return depPaths;
+  }
+
+  async getIdeConfiguration(ide) {
+    const config = await this.load();
+    const ideConfigs = config['ide-configurations'] || {};
+    return ideConfigs[ide] || null;
+  }
+
+  getBmadCorePath() {
+    // Get the path to bmad-core relative to the installer (now under tools)
+    return path.join(__dirname, '..', '..', '..', 'bmad-core');
+  }
+
+  getDistPath() {
+    // Get the path to dist directory relative to the installer
+    return path.join(__dirname, '..', '..', '..', 'dist');
+  }
+
+  getAgentPath(agentId) {
+    return path.join(this.getBmadCorePath(), 'agents', `${agentId}.md`);
+  }
+
+  async getAvailableTeams() {
+    const teamsDir = path.join(this.getBmadCorePath(), 'agent-teams');
+
+    try {
+      const entries = await fs.readdir(teamsDir, { withFileTypes: true });
+      const teams = [];
+
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith('.yaml')) {
+          const teamPath = path.join(teamsDir, entry.name);
+
+          try {
+            const teamContent = await fs.readFile(teamPath, 'utf8');
+            const teamConfig = yaml.load(teamContent);
+
+            if (teamConfig.bundle) {
+              teams.push({
+                id: path.basename(entry.name, '.yaml'),
+                name: teamConfig.bundle.name || entry.name,
+                description: teamConfig.bundle.description || 'Team configuration',
+                icon: teamConfig.bundle.icon || '📋',
+              });
+            }
+          } catch (error) {
+            console.warn(`Warning: Could not load team config ${entry.name}: ${error.message}`);
+          }
+        }
+      }
+
+      return teams;
+    } catch (error) {
+      console.warn(`Warning: Could not scan teams directory: ${error.message}`);
+      return [];
+    }
+  }
+
+  getTeamPath(teamId) {
+    return path.join(this.getBmadCorePath(), 'agent-teams', `${teamId}.yaml`);
+  }
+
+  async getTeamDependencies(teamId) {
+    // Use DependencyResolver to dynamically parse team dependencies
+    const DependencyResolver = require('../../lib/dependency-resolver');
+    const resolver = new DependencyResolver(path.join(__dirname, '..', '..', '..'));
+
+    try {
+      const teamDeps = await resolver.resolveTeamDependencies(teamId);
+
+      // Convert to flat list of file paths
+      const depPaths = [];
+
+      // Add team config file
+      depPaths.push(`.bmad-core/agent-teams/${teamId}.yaml`);
+
+      // Add all agents
+      for (const agent of teamDeps.agents) {
+        const filePath = `.bmad-core/agents/${agent.id}.md`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
+        }
+      }
+
+      // Add all resolved resources
+      for (const resource of teamDeps.resources) {
+        const filePath = `.bmad-core/${resource.type}/${resource.id}.${resource.type === 'workflows' ? 'yaml' : 'md'}`;
+        if (!depPaths.includes(filePath)) {
+          depPaths.push(filePath);
+        }
+      }
+
+      return depPaths;
+    } catch (error) {
+      throw new Error(`Failed to resolve team dependencies for ${teamId}: ${error.message}`);
+    }
+  }
+}
+
+module.exports = new ConfigLoader();