713 lines
27 KiB
JavaScript
713 lines
27 KiB
JavaScript
const path = require('node:path');
|
|
const { BaseIdeSetup } = require('./_base-ide');
|
|
const prompts = require('../../../lib/prompts');
|
|
const { AgentCommandGenerator } = require('./shared/agent-command-generator');
|
|
const { BMAD_FOLDER_NAME, toDashPath } = require('./shared/path-utils');
|
|
const fs = require('fs-extra');
|
|
const csv = require('csv-parse/sync');
|
|
const yaml = require('yaml');
|
|
const {
|
|
ProjectionCompatibilityError,
|
|
validateHelpCatalogLoaderEntries,
|
|
validateGithubCopilotHelpLoaderEntries,
|
|
} = require('../core/projection-compatibility-validator');
|
|
|
|
/**
|
|
* GitHub Copilot setup handler
|
|
* Creates agents in .github/agents/, prompts in .github/prompts/,
|
|
* copilot-instructions.md, and configures VS Code settings
|
|
*/
|
|
class GitHubCopilotSetup extends BaseIdeSetup {
|
|
constructor() {
|
|
super('github-copilot', 'GitHub Copilot', false);
|
|
// Don't set configDir to '.github' — nearly every GitHub repo has that directory,
|
|
// which would cause the base detect() to false-positive. Use detectionPaths instead.
|
|
this.configDir = null;
|
|
this.githubDir = '.github';
|
|
this.agentsDir = 'agents';
|
|
this.promptsDir = 'prompts';
|
|
this.detectionPaths = ['.github/copilot-instructions.md', '.github/agents'];
|
|
}
|
|
|
|
/**
|
|
* Setup GitHub Copilot configuration
|
|
* @param {string} projectDir - Project directory
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @param {Object} options - Setup options
|
|
*/
|
|
async setup(projectDir, bmadDir, options = {}) {
|
|
if (!options.silent) await prompts.log.info(`Setting up ${this.name}...`);
|
|
|
|
// Create .github/agents and .github/prompts directories
|
|
const githubDir = path.join(projectDir, this.githubDir);
|
|
const agentsDir = path.join(githubDir, this.agentsDir);
|
|
const promptsDir = path.join(githubDir, this.promptsDir);
|
|
await this.ensureDir(agentsDir);
|
|
await this.ensureDir(promptsDir);
|
|
|
|
// Preserve any customised tool permissions from existing files before cleanup
|
|
this.existingToolPermissions = await this.collectExistingToolPermissions(projectDir);
|
|
|
|
// Clean up any existing BMAD files before reinstalling
|
|
await this.cleanup(projectDir);
|
|
|
|
// Load agent manifest for enriched descriptions
|
|
const agentManifest = await this.loadAgentManifest(bmadDir);
|
|
|
|
// Generate agent launchers
|
|
const agentGen = new AgentCommandGenerator(this.bmadFolderName);
|
|
const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(bmadDir, options.selectedModules || []);
|
|
|
|
// Create agent .agent.md files
|
|
let agentCount = 0;
|
|
for (const artifact of agentArtifacts) {
|
|
const agentMeta = agentManifest.get(artifact.name);
|
|
|
|
// Compute fileName first so we can look up any existing tool permissions
|
|
const dashName = toDashPath(artifact.relativePath);
|
|
const fileName = dashName.replace(/\.md$/, '.agent.md');
|
|
const toolsStr = this.getToolsForFile(fileName);
|
|
const agentContent = this.createAgentContent(artifact, agentMeta, toolsStr);
|
|
const targetPath = path.join(agentsDir, fileName);
|
|
await this.writeFile(targetPath, agentContent);
|
|
agentCount++;
|
|
}
|
|
|
|
// Generate prompt files from bmad-help.csv
|
|
const promptCount = await this.generatePromptFiles(projectDir, bmadDir, agentArtifacts, agentManifest);
|
|
|
|
// Generate copilot-instructions.md
|
|
await this.generateCopilotInstructions(projectDir, bmadDir, agentManifest, options);
|
|
|
|
if (!options.silent) await prompts.log.success(`${this.name} configured: ${agentCount} agents, ${promptCount} prompts → .github/`);
|
|
|
|
return {
|
|
success: true,
|
|
results: {
|
|
agents: agentCount,
|
|
workflows: promptCount,
|
|
tasks: 0,
|
|
tools: 0,
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Load agent manifest CSV into a Map keyed by agent name
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @returns {Map} Agent metadata keyed by name
|
|
*/
|
|
async loadAgentManifest(bmadDir) {
|
|
const manifestPath = path.join(bmadDir, '_config', 'agent-manifest.csv');
|
|
const agents = new Map();
|
|
|
|
if (!(await fs.pathExists(manifestPath))) {
|
|
return agents;
|
|
}
|
|
|
|
try {
|
|
const csvContent = await fs.readFile(manifestPath, 'utf8');
|
|
const records = csv.parse(csvContent, {
|
|
columns: true,
|
|
skip_empty_lines: true,
|
|
});
|
|
|
|
for (const record of records) {
|
|
agents.set(record.name, record);
|
|
}
|
|
} catch {
|
|
// Gracefully degrade if manifest is unreadable/malformed
|
|
}
|
|
|
|
return agents;
|
|
}
|
|
|
|
/**
|
|
* Load bmad-help.csv to drive prompt generation
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @returns {Array|null} Parsed CSV rows
|
|
*/
|
|
async loadBmadHelp(bmadDir) {
|
|
const helpPath = path.join(bmadDir, '_config', 'bmad-help.csv');
|
|
|
|
if (!(await fs.pathExists(helpPath))) {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const csvContent = await fs.readFile(helpPath, 'utf8');
|
|
const rows = csv.parse(csvContent, {
|
|
columns: true,
|
|
skip_empty_lines: true,
|
|
});
|
|
const sourcePath = `${this.bmadFolderName || BMAD_FOLDER_NAME}/_config/bmad-help.csv`;
|
|
validateHelpCatalogLoaderEntries(rows, { sourcePath });
|
|
validateGithubCopilotHelpLoaderEntries(rows, { sourcePath });
|
|
return rows;
|
|
} catch (error) {
|
|
// Gracefully degrade if help CSV is unreadable/malformed
|
|
// but fail-fast on deterministic compatibility contract violations.
|
|
if (error instanceof ProjectionCompatibilityError) {
|
|
throw error;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create agent .agent.md content with enriched description
|
|
* @param {Object} artifact - Agent artifact from AgentCommandGenerator
|
|
* @param {Object|undefined} manifestEntry - Agent manifest entry with metadata
|
|
* @returns {string} Agent file content
|
|
*/
|
|
createAgentContent(artifact, manifestEntry, toolsStr) {
|
|
// Build enriched description from manifest metadata
|
|
let description;
|
|
if (manifestEntry) {
|
|
const persona = manifestEntry.displayName || artifact.name;
|
|
const title = manifestEntry.title || this.formatTitle(artifact.name);
|
|
const capabilities = manifestEntry.capabilities || 'agent capabilities';
|
|
description = `${persona} — ${title}: ${capabilities}`;
|
|
} else {
|
|
description = `Activates the ${this.formatTitle(artifact.name)} agent persona.`;
|
|
}
|
|
|
|
// Build the agent file path for the activation block
|
|
const agentPath = artifact.agentPath || artifact.relativePath;
|
|
const agentFilePath = `{project-root}/${this.bmadFolderName}/${agentPath}`;
|
|
|
|
return `---
|
|
description: '${description.replaceAll("'", "''")}'
|
|
tools: ${toolsStr}
|
|
---
|
|
|
|
You must fully embody this agent's persona and follow all activation instructions exactly as specified.
|
|
|
|
<agent-activation CRITICAL="TRUE">
|
|
1. LOAD the FULL agent file from ${agentFilePath}
|
|
2. READ its entire contents - this contains the complete agent persona, menu, and instructions
|
|
3. FOLLOW every step in the <activation> section precisely
|
|
4. DISPLAY the welcome/greeting as instructed
|
|
5. PRESENT the numbered menu
|
|
6. WAIT for user input before proceeding
|
|
</agent-activation>
|
|
`;
|
|
}
|
|
|
|
/**
|
|
* Generate .prompt.md files for workflows, tasks, tech-writer commands, and agent activators
|
|
* @param {string} projectDir - Project directory
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @param {Array} agentArtifacts - Agent artifacts for activator generation
|
|
* @param {Map} agentManifest - Agent manifest data
|
|
* @returns {number} Count of prompts generated
|
|
*/
|
|
async generatePromptFiles(projectDir, bmadDir, agentArtifacts, agentManifest) {
|
|
const promptsDir = path.join(projectDir, this.githubDir, this.promptsDir);
|
|
let promptCount = 0;
|
|
|
|
// Load bmad-help.csv to drive workflow/task prompt generation
|
|
const helpEntries = await this.loadBmadHelp(bmadDir);
|
|
|
|
if (helpEntries) {
|
|
for (const entry of helpEntries) {
|
|
const command = entry.command;
|
|
if (!command) continue; // Skip entries without a command (tech-writer commands have no command column)
|
|
|
|
const workflowFile = entry['workflow-file'];
|
|
if (!workflowFile) continue; // Skip entries with no workflow file path
|
|
const promptFileName = `${command}.prompt.md`;
|
|
const toolsStr = this.getToolsForFile(promptFileName);
|
|
const promptContent = this.createWorkflowPromptContent(entry, workflowFile, toolsStr);
|
|
const promptPath = path.join(promptsDir, promptFileName);
|
|
await this.writeFile(promptPath, promptContent);
|
|
promptCount++;
|
|
}
|
|
|
|
// Generate tech-writer command prompts (entries with no command column)
|
|
for (const entry of helpEntries) {
|
|
if (entry.command) continue; // Already handled above
|
|
const techWriterPrompt = this.createTechWriterPromptContent(entry);
|
|
if (techWriterPrompt) {
|
|
const promptFileName = `${techWriterPrompt.fileName}.prompt.md`;
|
|
const promptPath = path.join(promptsDir, promptFileName);
|
|
await this.writeFile(promptPath, techWriterPrompt.content);
|
|
promptCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate agent activator prompts (Pattern D)
|
|
for (const artifact of agentArtifacts) {
|
|
const agentMeta = agentManifest.get(artifact.name);
|
|
const fileName = `bmad-${artifact.name}.prompt.md`;
|
|
const toolsStr = this.getToolsForFile(fileName);
|
|
const promptContent = this.createAgentActivatorPromptContent(artifact, agentMeta, toolsStr);
|
|
const promptPath = path.join(promptsDir, fileName);
|
|
await this.writeFile(promptPath, promptContent);
|
|
promptCount++;
|
|
}
|
|
|
|
return promptCount;
|
|
}
|
|
|
|
/**
|
|
* Create prompt content for a workflow/task entry from bmad-help.csv
|
|
* Determines the pattern (A, B, or A for .xml tasks) based on file extension
|
|
* @param {Object} entry - bmad-help.csv row
|
|
* @param {string} workflowFile - Workflow file path
|
|
* @returns {string} Prompt file content
|
|
*/
|
|
createWorkflowPromptContent(entry, workflowFile, toolsStr) {
|
|
const description = this.escapeYamlSingleQuote(this.createPromptDescription(entry.name));
|
|
// bmm/config.yaml is safe to hardcode here: these prompts are only generated when
|
|
// bmad-help.csv exists (bmm module data), so bmm is guaranteed to be installed.
|
|
const configLine = `1. Load {project-root}/${this.bmadFolderName}/bmm/config.yaml and store ALL fields as session variables`;
|
|
|
|
let body;
|
|
if (workflowFile.endsWith('.yaml')) {
|
|
// Pattern B: YAML-based workflows — use workflow engine
|
|
body = `${configLine}
|
|
2. Load the workflow engine at {project-root}/${this.bmadFolderName}/core/tasks/workflow.xml
|
|
3. Load and execute the workflow configuration at {project-root}/${workflowFile} using the engine from step 2`;
|
|
} else if (workflowFile.endsWith('.xml')) {
|
|
// Pattern A variant: XML tasks — load and execute directly
|
|
body = `${configLine}
|
|
2. Load and execute the task at {project-root}/${workflowFile}`;
|
|
} else {
|
|
// Pattern A: MD workflows — load and follow directly
|
|
body = `${configLine}
|
|
2. Load and follow the workflow at {project-root}/${workflowFile}`;
|
|
}
|
|
|
|
return `---
|
|
description: '${description}'
|
|
agent: 'agent'
|
|
tools: ${toolsStr}
|
|
---
|
|
|
|
${body}
|
|
`;
|
|
}
|
|
|
|
/**
|
|
* Create a short 2-5 word description for a prompt from the entry name
|
|
* @param {string} name - Entry name from bmad-help.csv
|
|
* @returns {string} Short description
|
|
*/
|
|
createPromptDescription(name) {
|
|
const descriptionMap = {
|
|
'Brainstorm Project': 'Brainstorm ideas',
|
|
'Market Research': 'Market research',
|
|
'Domain Research': 'Domain research',
|
|
'Technical Research': 'Technical research',
|
|
'Create Brief': 'Create product brief',
|
|
'Create PRD': 'Create PRD',
|
|
'Validate PRD': 'Validate PRD',
|
|
'Edit PRD': 'Edit PRD',
|
|
'Create UX': 'Create UX design',
|
|
'Create Architecture': 'Create architecture',
|
|
'Create Epics and Stories': 'Create epics and stories',
|
|
'Check Implementation Readiness': 'Check implementation readiness',
|
|
'Sprint Planning': 'Sprint planning',
|
|
'Sprint Status': 'Sprint status',
|
|
'Create Story': 'Create story',
|
|
'Validate Story': 'Validate story',
|
|
'Dev Story': 'Dev story',
|
|
'QA Automation Test': 'QA automation',
|
|
'Code Review': 'Code review',
|
|
Retrospective: 'Retrospective',
|
|
'Document Project': 'Document project',
|
|
'Generate Project Context': 'Generate project context',
|
|
'Quick Spec': 'Quick spec',
|
|
'Quick Dev': 'Quick dev',
|
|
'Correct Course': 'Correct course',
|
|
Brainstorming: 'Brainstorm ideas',
|
|
'Party Mode': 'Party mode',
|
|
'bmad-help': 'BMAD help',
|
|
'Index Docs': 'Index documents',
|
|
'Shard Document': 'Shard document',
|
|
'Editorial Review - Prose': 'Editorial review prose',
|
|
'Editorial Review - Structure': 'Editorial review structure',
|
|
'Adversarial Review (General)': 'Adversarial review',
|
|
};
|
|
|
|
return descriptionMap[name] || name;
|
|
}
|
|
|
|
/**
|
|
* Create prompt content for tech-writer agent-only commands (Pattern C)
|
|
* @param {Object} entry - bmad-help.csv row
|
|
* @returns {Object|null} { fileName, content } or null if not a tech-writer command
|
|
*/
|
|
createTechWriterPromptContent(entry) {
|
|
if (entry['agent-name'] !== 'tech-writer') return null;
|
|
|
|
const techWriterCommands = {
|
|
'Write Document': { code: 'WD', file: 'bmad-bmm-write-document', description: 'Write document' },
|
|
'Update Standards': { code: 'US', file: 'bmad-bmm-update-standards', description: 'Update standards' },
|
|
'Mermaid Generate': { code: 'MG', file: 'bmad-bmm-mermaid-generate', description: 'Mermaid generate' },
|
|
'Validate Document': { code: 'VD', file: 'bmad-bmm-validate-document', description: 'Validate document' },
|
|
'Explain Concept': { code: 'EC', file: 'bmad-bmm-explain-concept', description: 'Explain concept' },
|
|
};
|
|
|
|
const cmd = techWriterCommands[entry.name];
|
|
if (!cmd) return null;
|
|
|
|
const safeDescription = this.escapeYamlSingleQuote(cmd.description);
|
|
const toolsStr = this.getToolsForFile(`${cmd.file}.prompt.md`);
|
|
|
|
const content = `---
|
|
description: '${safeDescription}'
|
|
agent: 'agent'
|
|
tools: ${toolsStr}
|
|
---
|
|
|
|
1. Load {project-root}/${this.bmadFolderName}/bmm/config.yaml and store ALL fields as session variables
|
|
2. Load the full agent file from {project-root}/${this.bmadFolderName}/bmm/agents/tech-writer/tech-writer.md and activate the Paige (Technical Writer) persona
|
|
3. Execute the ${entry.name} menu command (${cmd.code})
|
|
`;
|
|
|
|
return { fileName: cmd.file, content };
|
|
}
|
|
|
|
/**
|
|
* Create agent activator prompt content (Pattern D)
|
|
* @param {Object} artifact - Agent artifact
|
|
* @param {Object|undefined} manifestEntry - Agent manifest entry
|
|
* @returns {string} Prompt file content
|
|
*/
|
|
createAgentActivatorPromptContent(artifact, manifestEntry, toolsStr) {
|
|
let description;
|
|
if (manifestEntry) {
|
|
description = manifestEntry.title || this.formatTitle(artifact.name);
|
|
} else {
|
|
description = this.formatTitle(artifact.name);
|
|
}
|
|
|
|
const safeDescription = this.escapeYamlSingleQuote(description);
|
|
const agentPath = artifact.agentPath || artifact.relativePath;
|
|
const agentFilePath = `{project-root}/${this.bmadFolderName}/${agentPath}`;
|
|
|
|
// bmm/config.yaml is safe to hardcode: agent activators are only generated from
|
|
// bmm agent artifacts, so bmm is guaranteed to be installed.
|
|
return `---
|
|
description: '${safeDescription}'
|
|
agent: 'agent'
|
|
tools: ${toolsStr}
|
|
---
|
|
|
|
1. Load {project-root}/${this.bmadFolderName}/bmm/config.yaml and store ALL fields as session variables
|
|
2. Load the full agent file from ${agentFilePath}
|
|
3. Follow ALL activation instructions in the agent file
|
|
4. Display the welcome/greeting as instructed
|
|
5. Present the numbered menu
|
|
6. Wait for user input before proceeding
|
|
`;
|
|
}
|
|
|
|
/**
|
|
* Generate copilot-instructions.md from module config
|
|
* @param {string} projectDir - Project directory
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @param {Map} agentManifest - Agent manifest data
|
|
*/
|
|
async generateCopilotInstructions(projectDir, bmadDir, agentManifest, options = {}) {
|
|
const configVars = await this.loadModuleConfig(bmadDir);
|
|
|
|
// Build the agents table from the manifest
|
|
let agentsTable = '| Agent | Persona | Title | Capabilities |\n|---|---|---|---|\n';
|
|
const agentOrder = [
|
|
'bmad-master',
|
|
'analyst',
|
|
'architect',
|
|
'dev',
|
|
'pm',
|
|
'qa',
|
|
'quick-flow-solo-dev',
|
|
'sm',
|
|
'tech-writer',
|
|
'ux-designer',
|
|
];
|
|
|
|
for (const agentName of agentOrder) {
|
|
const meta = agentManifest.get(agentName);
|
|
if (meta) {
|
|
const capabilities = meta.capabilities || 'agent capabilities';
|
|
const cleanTitle = (meta.title || '').replaceAll('""', '"');
|
|
agentsTable += `| ${agentName} | ${meta.displayName} | ${cleanTitle} | ${capabilities} |\n`;
|
|
}
|
|
}
|
|
|
|
const bmad = this.bmadFolderName;
|
|
const bmadSection = `# BMAD Method — Project Instructions
|
|
|
|
## Project Configuration
|
|
|
|
- **Project**: ${configVars.project_name || '{{project_name}}'}
|
|
- **User**: ${configVars.user_name || '{{user_name}}'}
|
|
- **Communication Language**: ${configVars.communication_language || '{{communication_language}}'}
|
|
- **Document Output Language**: ${configVars.document_output_language || '{{document_output_language}}'}
|
|
- **User Skill Level**: ${configVars.user_skill_level || '{{user_skill_level}}'}
|
|
- **Output Folder**: ${configVars.output_folder || '{{output_folder}}'}
|
|
- **Planning Artifacts**: ${configVars.planning_artifacts || '{{planning_artifacts}}'}
|
|
- **Implementation Artifacts**: ${configVars.implementation_artifacts || '{{implementation_artifacts}}'}
|
|
- **Project Knowledge**: ${configVars.project_knowledge || '{{project_knowledge}}'}
|
|
|
|
## BMAD Runtime Structure
|
|
|
|
- **Agent definitions**: \`${bmad}/bmm/agents/\` (BMM module) and \`${bmad}/core/agents/\` (core)
|
|
- **Workflow definitions**: \`${bmad}/bmm/workflows/\` (organized by phase)
|
|
- **Core tasks**: \`${bmad}/core/tasks/\` (help, editorial review, indexing, sharding, adversarial review)
|
|
- **Core workflows**: \`${bmad}/core/workflows/\` (brainstorming, party-mode, advanced-elicitation)
|
|
- **Workflow engine**: \`${bmad}/core/tasks/workflow.xml\` (executes YAML-based workflows)
|
|
- **Module configuration**: \`${bmad}/bmm/config.yaml\`
|
|
- **Core configuration**: \`${bmad}/core/config.yaml\`
|
|
- **Agent manifest**: \`${bmad}/_config/agent-manifest.csv\`
|
|
- **Workflow manifest**: \`${bmad}/_config/workflow-manifest.csv\`
|
|
- **Help manifest**: \`${bmad}/_config/bmad-help.csv\`
|
|
- **Agent memory**: \`${bmad}/_memory/\`
|
|
|
|
## Key Conventions
|
|
|
|
- Always load \`${bmad}/bmm/config.yaml\` before any agent activation or workflow execution
|
|
- Store all config fields as session variables: \`{user_name}\`, \`{communication_language}\`, \`{output_folder}\`, \`{planning_artifacts}\`, \`{implementation_artifacts}\`, \`{project_knowledge}\`
|
|
- MD-based workflows execute directly — load and follow the \`.md\` file
|
|
- YAML-based workflows require the workflow engine — load \`workflow.xml\` first, then pass the \`.yaml\` config
|
|
- Follow step-based workflow execution: load steps JIT, never multiple at once
|
|
- Save outputs after EACH step when using the workflow engine
|
|
- The \`{project-root}\` variable resolves to the workspace root at runtime
|
|
|
|
## Available Agents
|
|
|
|
${agentsTable}
|
|
## Slash Commands
|
|
|
|
Type \`/bmad-\` in Copilot Chat to see all available BMAD workflows and agent activators. Agents are also available in the agents dropdown.`;
|
|
|
|
const instructionsPath = path.join(projectDir, this.githubDir, 'copilot-instructions.md');
|
|
const markerStart = '<!-- BMAD:START -->';
|
|
const markerEnd = '<!-- BMAD:END -->';
|
|
const markedContent = `${markerStart}\n${bmadSection}\n${markerEnd}`;
|
|
|
|
if (await fs.pathExists(instructionsPath)) {
|
|
const existing = await fs.readFile(instructionsPath, 'utf8');
|
|
const startIdx = existing.indexOf(markerStart);
|
|
const endIdx = existing.indexOf(markerEnd);
|
|
|
|
if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
|
|
// Replace only the BMAD section between markers
|
|
const before = existing.slice(0, startIdx);
|
|
const after = existing.slice(endIdx + markerEnd.length);
|
|
const merged = `${before}${markedContent}${after}`;
|
|
await this.writeFile(instructionsPath, merged);
|
|
} else {
|
|
// Existing file without markers — back it up before overwriting
|
|
const backupPath = `${instructionsPath}.bak`;
|
|
await fs.copy(instructionsPath, backupPath);
|
|
if (!options.silent) await prompts.log.warn(` Backed up copilot-instructions.md → .bak`);
|
|
await this.writeFile(instructionsPath, `${markedContent}\n`);
|
|
}
|
|
} else {
|
|
// No existing file — create fresh with markers
|
|
await this.writeFile(instructionsPath, `${markedContent}\n`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load module config.yaml for template variables
|
|
* @param {string} bmadDir - BMAD installation directory
|
|
* @returns {Object} Config variables
|
|
*/
|
|
async loadModuleConfig(bmadDir) {
|
|
const bmmConfigPath = path.join(bmadDir, 'bmm', 'config.yaml');
|
|
const coreConfigPath = path.join(bmadDir, 'core', 'config.yaml');
|
|
|
|
for (const configPath of [bmmConfigPath, coreConfigPath]) {
|
|
if (await fs.pathExists(configPath)) {
|
|
try {
|
|
const content = await fs.readFile(configPath, 'utf8');
|
|
return yaml.parse(content) || {};
|
|
} catch {
|
|
// Fall through to next config
|
|
}
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
/**
|
|
* Escape a string for use inside YAML single-quoted values.
|
|
* In YAML, the only escape inside single quotes is '' for a literal '.
|
|
* @param {string} value - Raw string
|
|
* @returns {string} Escaped string safe for YAML single-quoted context
|
|
*/
|
|
escapeYamlSingleQuote(value) {
|
|
return (value || '').replaceAll("'", "''");
|
|
}
|
|
|
|
/**
|
|
* Scan existing agent and prompt files for customised tool permissions before cleanup.
|
|
* Returns a Map<filename, toolsArray> so permissions can be preserved across reinstalls.
|
|
* @param {string} projectDir - Project directory
|
|
* @returns {Map} Existing tool permissions keyed by filename
|
|
*/
|
|
async collectExistingToolPermissions(projectDir) {
|
|
const permissions = new Map();
|
|
const dirs = [
|
|
[path.join(projectDir, this.githubDir, this.agentsDir), /^bmad.*\.agent\.md$/],
|
|
[path.join(projectDir, this.githubDir, this.promptsDir), /^bmad-.*\.prompt\.md$/],
|
|
];
|
|
|
|
for (const [dir, pattern] of dirs) {
|
|
if (!(await fs.pathExists(dir))) continue;
|
|
const files = await fs.readdir(dir);
|
|
|
|
for (const file of files) {
|
|
if (!pattern.test(file)) continue;
|
|
|
|
try {
|
|
const content = await fs.readFile(path.join(dir, file), 'utf8');
|
|
const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
|
|
if (!fmMatch) continue;
|
|
|
|
const frontmatter = yaml.parse(fmMatch[1]);
|
|
if (frontmatter && Array.isArray(frontmatter.tools)) {
|
|
permissions.set(file, frontmatter.tools);
|
|
}
|
|
} catch {
|
|
// Skip unreadable files
|
|
}
|
|
}
|
|
}
|
|
|
|
return permissions;
|
|
}
|
|
|
|
/**
|
|
* Get the tools array string for a file, preserving any existing customisation.
|
|
* Falls back to the default tools if no prior customisation exists.
|
|
* @param {string} fileName - Target filename (e.g. 'bmad-agent-bmm-pm.agent.md')
|
|
* @returns {string} YAML inline array string
|
|
*/
|
|
getToolsForFile(fileName) {
|
|
const defaultTools = ['read', 'edit', 'search', 'execute'];
|
|
const tools = (this.existingToolPermissions && this.existingToolPermissions.get(fileName)) || defaultTools;
|
|
return '[' + tools.map((t) => `'${t}'`).join(', ') + ']';
|
|
}
|
|
|
|
/**
|
|
* Format name as title
|
|
*/
|
|
formatTitle(name) {
|
|
return name
|
|
.split('-')
|
|
.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
|
|
.join(' ');
|
|
}
|
|
|
|
/**
|
|
* Cleanup GitHub Copilot configuration - surgically remove only BMAD files
|
|
*/
|
|
async cleanup(projectDir, options = {}) {
|
|
// Clean up agents directory
|
|
const agentsDir = path.join(projectDir, this.githubDir, this.agentsDir);
|
|
if (await fs.pathExists(agentsDir)) {
|
|
const files = await fs.readdir(agentsDir);
|
|
let removed = 0;
|
|
|
|
for (const file of files) {
|
|
if (file.startsWith('bmad') && (file.endsWith('.agent.md') || file.endsWith('.md'))) {
|
|
await fs.remove(path.join(agentsDir, file));
|
|
removed++;
|
|
}
|
|
}
|
|
|
|
if (removed > 0 && !options.silent) {
|
|
await prompts.log.message(` Cleaned up ${removed} existing BMAD agents`);
|
|
}
|
|
}
|
|
|
|
// Clean up prompts directory
|
|
const promptsDir = path.join(projectDir, this.githubDir, this.promptsDir);
|
|
if (await fs.pathExists(promptsDir)) {
|
|
const files = await fs.readdir(promptsDir);
|
|
let removed = 0;
|
|
|
|
for (const file of files) {
|
|
if (file.startsWith('bmad-') && file.endsWith('.prompt.md')) {
|
|
await fs.remove(path.join(promptsDir, file));
|
|
removed++;
|
|
}
|
|
}
|
|
|
|
if (removed > 0 && !options.silent) {
|
|
await prompts.log.message(` Cleaned up ${removed} existing BMAD prompts`);
|
|
}
|
|
}
|
|
|
|
// During uninstall, also strip BMAD markers from copilot-instructions.md.
|
|
// During reinstall (default), this is skipped because generateCopilotInstructions()
|
|
// handles marker-based replacement in a single read-modify-write pass,
|
|
// which correctly preserves user content outside the markers.
|
|
if (options.isUninstall) {
|
|
await this.cleanupCopilotInstructions(projectDir, options);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Strip BMAD marker section from copilot-instructions.md
|
|
* If file becomes empty after stripping, delete it.
|
|
* If a .bak backup exists and the main file was deleted, restore the backup.
|
|
* @param {string} projectDir - Project directory
|
|
* @param {Object} [options] - Options (e.g. { silent: true })
|
|
*/
|
|
async cleanupCopilotInstructions(projectDir, options = {}) {
|
|
const instructionsPath = path.join(projectDir, this.githubDir, 'copilot-instructions.md');
|
|
const backupPath = `${instructionsPath}.bak`;
|
|
|
|
if (!(await fs.pathExists(instructionsPath))) {
|
|
return;
|
|
}
|
|
|
|
const content = await fs.readFile(instructionsPath, 'utf8');
|
|
const markerStart = '<!-- BMAD:START -->';
|
|
const markerEnd = '<!-- BMAD:END -->';
|
|
const startIdx = content.indexOf(markerStart);
|
|
const endIdx = content.indexOf(markerEnd);
|
|
|
|
if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
|
|
return; // No valid markers found
|
|
}
|
|
|
|
// Strip the marker section (including markers)
|
|
const before = content.slice(0, startIdx);
|
|
const after = content.slice(endIdx + markerEnd.length);
|
|
const cleaned = before + after;
|
|
|
|
if (cleaned.trim().length === 0) {
|
|
// File is empty after stripping — delete it
|
|
await fs.remove(instructionsPath);
|
|
|
|
// If backup exists, restore it
|
|
if (await fs.pathExists(backupPath)) {
|
|
await fs.rename(backupPath, instructionsPath);
|
|
if (!options.silent) {
|
|
await prompts.log.message(' Restored copilot-instructions.md from backup');
|
|
}
|
|
}
|
|
} else {
|
|
// Write cleaned content back (preserve original whitespace)
|
|
await fs.writeFile(instructionsPath, cleaned, 'utf8');
|
|
|
|
// If backup exists, it's stale now — remove it
|
|
if (await fs.pathExists(backupPath)) {
|
|
await fs.remove(backupPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = { GitHubCopilotSetup };
|