mirror of
https://github.com/bmadcode/BMAD-METHOD.git
synced 2025-12-17 17:55:34 +00:00
302 lines
11 KiB
JavaScript
302 lines
11 KiB
JavaScript
const path = require('node:path');
|
|
const fs = require('fs-extra');
|
|
const yaml = require('js-yaml');
|
|
const { BaseIdeSetup } = require('./_base-ide');
|
|
const chalk = require('chalk');
|
|
const { AgentCommandGenerator } = require('./shared/agent-command-generator');
|
|
const { WorkflowCommandGenerator } = require('./shared/workflow-command-generator');
|
|
|
|
/**
|
|
* Gemini CLI setup handler
|
|
* Creates TOML files in .gemini/commands/ structure
|
|
*/
|
|
class GeminiSetup extends BaseIdeSetup {
|
|
constructor() {
|
|
super('gemini', 'Gemini CLI', false);
|
|
this.configDir = '.gemini';
|
|
this.commandsDir = 'commands';
|
|
this.agentTemplatePath = path.join(__dirname, 'templates', 'gemini-agent-command.toml');
|
|
this.taskTemplatePath = path.join(__dirname, 'templates', 'gemini-task-command.toml');
|
|
}
|
|
|
|
/**
|
|
* Load config values from bmad installation
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @returns {Object} Config values
|
|
*/
|
|
async loadConfigValues(bmadDir) {
|
|
const configValues = {
|
|
user_name: 'User', // Default fallback
|
|
};
|
|
|
|
// Try to load core config.yaml
|
|
const coreConfigPath = path.join(bmadDir, 'core', 'config.yaml');
|
|
if (await fs.pathExists(coreConfigPath)) {
|
|
try {
|
|
const configContent = await fs.readFile(coreConfigPath, 'utf8');
|
|
const config = yaml.load(configContent);
|
|
|
|
if (config.user_name) {
|
|
configValues.user_name = config.user_name;
|
|
}
|
|
} catch (error) {
|
|
console.warn(chalk.yellow(` Warning: Could not load config values: ${error.message}`));
|
|
}
|
|
}
|
|
|
|
return configValues;
|
|
}
|
|
|
|
/**
|
|
* Setup Gemini 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}...`));
|
|
|
|
// Create .gemini/commands directory (flat structure with bmad- prefix)
|
|
const geminiDir = path.join(projectDir, this.configDir);
|
|
const commandsDir = path.join(geminiDir, this.commandsDir);
|
|
|
|
await this.ensureDir(commandsDir);
|
|
|
|
// Clean up any existing BMAD files before reinstalling
|
|
await this.cleanup(projectDir);
|
|
|
|
// Generate agent launchers
|
|
const agentGen = new AgentCommandGenerator(this.bmadFolderName);
|
|
const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
|
|
|
|
// Get tasks and workflows (ALL workflows now generate commands)
|
|
const tasks = await this.getTasks(bmadDir);
|
|
|
|
// Get ALL workflows using the new workflow command generator
|
|
const workflowGenerator = new WorkflowCommandGenerator(this.bmadFolderName);
|
|
const { artifacts: workflowArtifacts, counts: workflowCounts } = await workflowGenerator.collectWorkflowArtifacts(bmadDir);
|
|
|
|
// Install agents as TOML files with bmad- prefix (flat structure)
|
|
let agentCount = 0;
|
|
for (const artifact of agentArtifacts) {
|
|
const tomlContent = await this.createAgentLauncherToml(artifact);
|
|
|
|
// Flat structure: bmad-agent-{module}-{name}.toml
|
|
const tomlPath = path.join(commandsDir, `bmad-agent-${artifact.module}-${artifact.name}.toml`);
|
|
await this.writeFile(tomlPath, tomlContent);
|
|
agentCount++;
|
|
|
|
console.log(chalk.green(` ✓ Added agent: /bmad:agents:${artifact.module}:${artifact.name}`));
|
|
}
|
|
|
|
// Install tasks as TOML files with bmad- prefix (flat structure)
|
|
let taskCount = 0;
|
|
for (const task of tasks) {
|
|
const content = await this.readFile(task.path);
|
|
const tomlContent = await this.createTaskToml(task, content);
|
|
|
|
// Flat structure: bmad-task-{module}-{name}.toml
|
|
const tomlPath = path.join(commandsDir, `bmad-task-${task.module}-${task.name}.toml`);
|
|
await this.writeFile(tomlPath, tomlContent);
|
|
taskCount++;
|
|
|
|
console.log(chalk.green(` ✓ Added task: /bmad:tasks:${task.module}:${task.name}`));
|
|
}
|
|
|
|
// Install workflows as TOML files with bmad- prefix (flat structure)
|
|
let workflowCount = 0;
|
|
for (const artifact of workflowArtifacts) {
|
|
if (artifact.type === 'workflow-command') {
|
|
// Create TOML wrapper around workflow command content
|
|
const tomlContent = await this.createWorkflowToml(artifact);
|
|
|
|
// Flat structure: bmad-workflow-{module}-{name}.toml
|
|
const workflowName = path.basename(artifact.relativePath, '.md');
|
|
const tomlPath = path.join(commandsDir, `bmad-workflow-${artifact.module}-${workflowName}.toml`);
|
|
await this.writeFile(tomlPath, tomlContent);
|
|
workflowCount++;
|
|
|
|
console.log(chalk.green(` ✓ Added workflow: /bmad:workflows:${artifact.module}:${workflowName}`));
|
|
}
|
|
}
|
|
|
|
console.log(chalk.green(`✓ ${this.name} configured:`));
|
|
console.log(chalk.dim(` - ${agentCount} agents configured`));
|
|
console.log(chalk.dim(` - ${taskCount} tasks configured`));
|
|
console.log(chalk.dim(` - ${workflowCount} workflows configured`));
|
|
console.log(chalk.dim(` - Commands directory: ${path.relative(projectDir, commandsDir)}`));
|
|
console.log(chalk.dim(` - Agent activation: /bmad:agents:{agent-name}`));
|
|
console.log(chalk.dim(` - Task activation: /bmad:tasks:{task-name}`));
|
|
console.log(chalk.dim(` - Workflow activation: /bmad:workflows:{workflow-name}`));
|
|
|
|
return {
|
|
success: true,
|
|
agents: agentCount,
|
|
tasks: taskCount,
|
|
workflows: workflowCount,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Create agent launcher TOML content from artifact
|
|
*/
|
|
async createAgentLauncherToml(artifact) {
|
|
// Strip frontmatter from launcher content
|
|
const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
|
|
const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
|
|
|
|
// Extract title from launcher frontmatter
|
|
const titleMatch = artifact.content.match(/description:\s*"([^"]+)"/);
|
|
const title = titleMatch ? titleMatch[1] : this.formatTitle(artifact.name);
|
|
|
|
// Create TOML wrapper around launcher content (without frontmatter)
|
|
const description = `BMAD ${artifact.module.toUpperCase()} Agent: ${title}`;
|
|
|
|
return `description = "${description}"
|
|
prompt = """
|
|
${contentWithoutFrontmatter}
|
|
"""
|
|
`;
|
|
}
|
|
|
|
/**
|
|
* Create agent TOML content using template
|
|
*/
|
|
async createAgentToml(agent, content) {
|
|
// Extract metadata
|
|
const titleMatch = content.match(/title="([^"]+)"/);
|
|
const title = titleMatch ? titleMatch[1] : this.formatTitle(agent.name);
|
|
|
|
// Load template
|
|
const template = await fs.readFile(this.agentTemplatePath, 'utf8');
|
|
|
|
// Replace template variables
|
|
// Note: {user_name} and other {config_values} are left as-is for runtime substitution by Gemini
|
|
const tomlContent = template
|
|
.replaceAll('{{title}}', title)
|
|
.replaceAll('{{*bmad_folder*}}', '{bmad_folder}')
|
|
.replaceAll('{{bmad_folder}}', this.bmadFolderName)
|
|
.replaceAll('{{module}}', agent.module)
|
|
.replaceAll('{{name}}', agent.name);
|
|
|
|
return tomlContent;
|
|
}
|
|
|
|
/**
|
|
* Create task TOML content using template
|
|
*/
|
|
async createTaskToml(task, content) {
|
|
// Extract task name from XML if available
|
|
const nameMatch = content.match(/<name>([^<]+)<\/name>/);
|
|
const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
|
|
|
|
// Load template
|
|
const template = await fs.readFile(this.taskTemplatePath, 'utf8');
|
|
|
|
// Replace template variables
|
|
const tomlContent = template
|
|
.replaceAll('{{taskName}}', taskName)
|
|
.replaceAll('{{*bmad_folder*}}', '{bmad_folder}')
|
|
.replaceAll('{{bmad_folder}}', this.bmadFolderName)
|
|
.replaceAll('{{module}}', task.module)
|
|
.replaceAll('{{filename}}', task.filename);
|
|
|
|
return tomlContent;
|
|
}
|
|
|
|
/**
|
|
* Create workflow TOML content from artifact
|
|
*/
|
|
async createWorkflowToml(artifact) {
|
|
// Extract description from artifact content
|
|
const descriptionMatch = artifact.content.match(/description:\s*"([^"]+)"/);
|
|
const description = descriptionMatch
|
|
? descriptionMatch[1]
|
|
: `BMAD ${artifact.module.toUpperCase()} Workflow: ${path.basename(artifact.relativePath, '.md')}`;
|
|
|
|
// Strip frontmatter from command content
|
|
const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
|
|
const contentWithoutFrontmatter = artifact.content.replace(frontmatterRegex, '').trim();
|
|
|
|
return `description = "${description}"
|
|
prompt = """
|
|
${contentWithoutFrontmatter}
|
|
"""
|
|
`;
|
|
}
|
|
|
|
/**
|
|
* Cleanup Gemini configuration - surgically remove only BMAD files
|
|
*/
|
|
async cleanup(projectDir) {
|
|
const fs = require('fs-extra');
|
|
const commandsDir = path.join(projectDir, this.configDir, this.commandsDir);
|
|
|
|
if (await fs.pathExists(commandsDir)) {
|
|
// Only remove files that start with bmad- prefix
|
|
const files = await fs.readdir(commandsDir);
|
|
let removed = 0;
|
|
|
|
for (const file of files) {
|
|
if (file.startsWith('bmad-') && file.endsWith('.toml')) {
|
|
await fs.remove(path.join(commandsDir, file));
|
|
removed++;
|
|
}
|
|
}
|
|
|
|
if (removed > 0) {
|
|
console.log(chalk.dim(` Cleaned up ${removed} existing BMAD files`));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Install a custom agent launcher for Gemini
|
|
* @param {string} projectDir - Project directory
|
|
* @param {string} agentName - Agent name (e.g., "fred-commit-poet")
|
|
* @param {string} agentPath - Path to compiled agent (relative to project root)
|
|
* @param {Object} metadata - Agent metadata
|
|
* @returns {Object} Installation result
|
|
*/
|
|
async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
|
|
const geminiDir = path.join(projectDir, this.configDir);
|
|
const commandsDir = path.join(geminiDir, this.commandsDir);
|
|
|
|
// Create .gemini/commands directory if it doesn't exist
|
|
await fs.ensureDir(commandsDir);
|
|
|
|
// Create custom agent launcher in TOML format
|
|
const launcherContent = `description = "Custom BMAD Agent: ${agentName}"
|
|
prompt = """
|
|
**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
|
|
|
|
This is a launcher for the custom BMAD agent "${agentName}".
|
|
|
|
## Usage
|
|
1. First run: \`${agentPath}\` to load the complete agent
|
|
2. Then use this command to activate ${agentName}
|
|
|
|
The agent will follow the persona and instructions from the main agent file.
|
|
|
|
---
|
|
|
|
*Generated by BMAD Method*
|
|
"""`;
|
|
|
|
const fileName = `bmad-custom-${agentName.toLowerCase()}.toml`;
|
|
const launcherPath = path.join(commandsDir, fileName);
|
|
|
|
// Write the launcher file
|
|
await fs.writeFile(launcherPath, launcherContent, 'utf8');
|
|
|
|
return {
|
|
ide: 'gemini',
|
|
path: path.relative(projectDir, launcherPath),
|
|
command: agentName,
|
|
type: 'custom-agent-launcher',
|
|
};
|
|
}
|
|
}
|
|
|
|
module.exports = { GeminiSetup };
|