aided-dev 1.0.0

package/dist/bmad/loader.js

@@ -0,0 +1,482 @@
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'js-yaml';
+export function findBMADPath() {
+    const possiblePaths = [
+        path.resolve(process.cwd(), 'node_modules/bmad-method'),
+        path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../node_modules/bmad-method'),
+        path.resolve(process.cwd(), '../BMAD-METHOD'),
+        process.env.BMAD_PATH,
+    ].filter(Boolean);
+    for (const bmadPath of possiblePaths) {
+        if (fs.existsSync(path.join(bmadPath, 'package.json'))) {
+            try {
+                const pkg = fs.readJsonSync(path.join(bmadPath, 'package.json'));
+                if (pkg.name === 'bmad-method') {
+                    return bmadPath;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return undefined;
+}
+function extractYamlFromMarkdown(content) {
+    const yamlMatch = content.match(/```yaml\n([\s\S]*?)\n```/);
+    if (yamlMatch) {
+        return yamlMatch[1];
+    }
+    return undefined;
+}
+function parseMarkdownAgent(content) {
+    const yamlContent = extractYamlFromMarkdown(content);
+    if (!yamlContent)
+        return undefined;
+    try {
+        const parsed = yaml.load(yamlContent);
+        const agent = parsed.agent;
+        const persona = parsed.persona;
+        if (!agent || !persona)
+            return undefined;
+        return {
+            agent,
+            persona,
+            commands: parsed.commands,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseYamlAgent(content) {
+    try {
+        const parsed = yaml.load(content);
+        return parsed?.agent;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function loadAgentFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (filePath.endsWith('.md')) {
+            return parseMarkdownAgent(content);
+        }
+        else if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
+            return parseYamlAgent(content);
+        }
+        return undefined;
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+export function buildSystemPrompt(agent) {
+    const name = agent.agent?.name || agent.metadata?.name || 'Agent';
+    const title = agent.agent?.title || agent.metadata?.title || '';
+    const persona = agent.persona;
+    let prompt = `You are ${name}, ${title}.\n\n`;
+    prompt += `## Role\n${persona.role}\n\n`;
+    prompt += `## Identity\n${persona.identity}\n\n`;
+    const style = persona.communication_style || persona.style;
+    if (style) {
+        prompt += `## Communication Style\n${style}\n\n`;
+    }
+    if (persona.focus) {
+        prompt += `## Focus\n${persona.focus}\n\n`;
+    }
+    if (persona.principles) {
+        prompt += `## Principles\n${persona.principles}\n`;
+    }
+    else if (persona.core_principles && persona.core_principles.length > 0) {
+        prompt += `## Principles\n`;
+        for (const principle of persona.core_principles) {
+            prompt += `- ${principle}\n`;
+        }
+    }
+    if (agent.critical_actions && agent.critical_actions.length > 0) {
+        prompt += `\n## Critical Actions\n`;
+        for (const action of agent.critical_actions) {
+            prompt += `- ${action}\n`;
+        }
+    }
+    return prompt;
+}
+export function toAgentConfig(agent) {
+    const name = agent.agent?.name || agent.metadata?.name || 'Agent';
+    const title = agent.agent?.title || agent.metadata?.title || '';
+    const icon = agent.agent?.icon || agent.metadata?.icon || '🤖';
+    return {
+        name,
+        title,
+        icon,
+        systemPrompt: buildSystemPrompt(agent),
+        persona: agent.persona,
+        criticalActions: agent.critical_actions || [],
+    };
+}
+export class BMADLoader {
+    bmadPath;
+    agentsPaths = [];
+    agentCache = new Map();
+    formatType = 'unknown';
+    constructor(bmadPath) {
+        this.bmadPath = bmadPath || findBMADPath();
+        if (this.bmadPath) {
+            const npmAgentsPath = path.join(this.bmadPath, 'bmad-core/agents');
+            const localAgentsPath = path.join(this.bmadPath, 'src/modules/bmm/agents');
+            if (fs.existsSync(npmAgentsPath)) {
+                this.formatType = 'npm';
+                this.agentsPaths = [npmAgentsPath];
+                const expansionPath = path.join(this.bmadPath, 'expansion-packs');
+                if (fs.existsSync(expansionPath)) {
+                    const packs = fs.readdirSync(expansionPath);
+                    for (const pack of packs) {
+                        const packAgentsPath = path.join(expansionPath, pack, 'agents');
+                        if (fs.existsSync(packAgentsPath)) {
+                            this.agentsPaths.push(packAgentsPath);
+                        }
+                    }
+                }
+            }
+            else if (fs.existsSync(localAgentsPath)) {
+                this.formatType = 'local';
+                this.agentsPaths = [localAgentsPath];
+            }
+        }
+    }
+    isAvailable() {
+        return !!this.bmadPath && this.agentsPaths.length > 0;
+    }
+    getPath() {
+        return this.bmadPath;
+    }
+    getFormatType() {
+        return this.formatType;
+    }
+    async listAgents() {
+        const agents = [];
+        for (const agentsPath of this.agentsPaths) {
+            if (!fs.existsSync(agentsPath))
+                continue;
+            const files = await fs.readdir(agentsPath);
+            for (const file of files) {
+                if (file.endsWith('.md') && !file.startsWith('_')) {
+                    agents.push(file.replace('.md', ''));
+                }
+                else if (file.endsWith('.agent.yaml')) {
+                    agents.push(file.replace('.agent.yaml', ''));
+                }
+            }
+        }
+        return [...new Set(agents)];
+    }
+    async loadAgent(name) {
+        if (this.agentCache.has(name)) {
+            return this.agentCache.get(name);
+        }
+        for (const agentsPath of this.agentsPaths) {
+            const mdPath = path.join(agentsPath, `${name}.md`);
+            if (fs.existsSync(mdPath)) {
+                const agent = await loadAgentFile(mdPath);
+                if (agent) {
+                    const config = toAgentConfig(agent);
+                    this.agentCache.set(name, config);
+                    return config;
+                }
+            }
+            const yamlPath = path.join(agentsPath, `${name}.agent.yaml`);
+            if (fs.existsSync(yamlPath)) {
+                const agent = await loadAgentFile(yamlPath);
+                if (agent) {
+                    const config = toAgentConfig(agent);
+                    this.agentCache.set(name, config);
+                    return config;
+                }
+            }
+        }
+        return this.getFallbackAgent(name);
+    }
+    async loadAgents(names) {
+        const result = new Map();
+        for (const name of names) {
+            const agent = await this.loadAgent(name);
+            if (agent) {
+                result.set(name, agent);
+            }
+        }
+        return result;
+    }
+    getLoadedAgents() {
+        return this.agentCache;
+    }
+    getFallbackAgent(name) {
+        const fallbacks = {
+            analyst: {
+                name: 'Mary',
+                title: 'Business Analyst',
+                icon: '📊',
+                systemPrompt: `You are Mary, a Senior Business Analyst.
+
+## Role
+Strategic Business Analyst + Requirements Expert
+
+## Identity
+Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation. Specializes in translating vague needs into actionable specs.
+
+## Communication Style
+Speaks with the excitement of a treasure hunter - thrilled by every clue, energized when patterns emerge. Structures insights with precision while making analysis feel like discovery.
+
+## Principles
+- Channel expert business analysis frameworks
+- Articulate requirements with absolute precision
+- Ensure all stakeholder voices heard`,
+                persona: {
+                    role: 'Strategic Business Analyst + Requirements Expert',
+                    identity: 'Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation.',
+                    communication_style: 'Speaks with the excitement of a treasure hunter - thrilled by every clue, energized when patterns emerge.',
+                    principles: 'Channel expert business analysis frameworks. Articulate requirements with absolute precision.',
+                },
+                criticalActions: [],
+            },
+            architect: {
+                name: 'Winston',
+                title: 'Architect',
+                icon: '🏗️',
+                systemPrompt: `You are Winston, a Senior System Architect.
+
+## Role
+System Architect + Technical Design Leader
+
+## Identity
+Senior architect with expertise in distributed systems, cloud infrastructure, and API design. Specializes in scalable patterns and technology selection.
+
+## Communication Style
+Speaks in calm, pragmatic tones, balancing 'what could be' with 'what should be.'
+
+## Principles
+- Channel expert lean architecture wisdom
+- User journeys drive technical decisions
+- Design simple solutions that scale when needed
+- Connect every decision to business value`,
+                persona: {
+                    role: 'System Architect + Technical Design Leader',
+                    identity: 'Senior architect with expertise in distributed systems, cloud infrastructure, and API design.',
+                    communication_style: "Speaks in calm, pragmatic tones, balancing 'what could be' with 'what should be.'",
+                    principles: 'Channel expert lean architecture wisdom. Design simple solutions that scale when needed.',
+                },
+                criticalActions: [],
+            },
+            dev: {
+                name: 'Amelia',
+                title: 'Developer Agent',
+                icon: '💻',
+                systemPrompt: `You are Amelia, a Senior Software Engineer.
+
+## Role
+Senior Software Engineer
+
+## Identity
+Executes approved stories with strict adherence to acceptance criteria, using existing code to minimize rework and hallucinations.
+
+## Communication Style
+Ultra-succinct. Speaks in file paths and AC IDs - every statement citable. No fluff, all precision.
+
+## Principles
+- Follow red-green-refactor cycle
+- Never implement anything not mapped to a specific task
+- All existing tests must pass 100%
+- Every task must be covered by comprehensive unit tests`,
+                persona: {
+                    role: 'Senior Software Engineer',
+                    identity: 'Executes approved stories with strict adherence to acceptance criteria.',
+                    communication_style: 'Ultra-succinct. Speaks in file paths and AC IDs - every statement citable.',
+                    principles: 'Follow red-green-refactor cycle. All tests must pass 100%.',
+                },
+                criticalActions: [
+                    'READ the entire story file BEFORE any implementation',
+                    'Execute tasks IN ORDER as written',
+                    'Run full test suite after each task',
+                ],
+            },
+            qa: {
+                name: 'Murat',
+                title: 'QA Engineer',
+                icon: '🧪',
+                systemPrompt: `You are Murat, a QA Engineer and Test Architect.
+
+## Role
+QA Engineer + Test Architect
+
+## Identity
+Expert in test strategy, automation frameworks, and quality assurance. Ensures comprehensive coverage and reliable test suites.
+
+## Communication Style
+Methodical and thorough. Thinks about edge cases others miss.
+
+## Principles
+- Test behavior, not implementation
+- Cover happy paths and edge cases
+- Tests should be reliable and repeatable
+- Fast feedback is essential`,
+                persona: {
+                    role: 'QA Engineer + Test Architect',
+                    identity: 'Expert in test strategy, automation frameworks, and quality assurance.',
+                    communication_style: 'Methodical and thorough. Thinks about edge cases others miss.',
+                    principles: 'Test behavior, not implementation. Fast feedback is essential.',
+                },
+                criticalActions: [],
+            },
+            tea: {
+                name: 'Murat',
+                title: 'Test Architect',
+                icon: '🧪',
+                systemPrompt: `You are Murat, a Test Engineering Architect.
+
+## Role
+Test Engineering Architect
+
+## Identity
+Expert in test strategy, automation frameworks, and quality assurance. Ensures comprehensive coverage and reliable test suites.
+
+## Communication Style
+Methodical and thorough. Thinks about edge cases others miss.
+
+## Principles
+- Test behavior, not implementation
+- Cover happy paths and edge cases
+- Tests should be reliable and repeatable
+- Fast feedback is essential`,
+                persona: {
+                    role: 'Test Engineering Architect',
+                    identity: 'Expert in test strategy, automation frameworks, and quality assurance.',
+                    communication_style: 'Methodical and thorough. Thinks about edge cases others miss.',
+                    principles: 'Test behavior, not implementation. Fast feedback is essential.',
+                },
+                criticalActions: [],
+            },
+            pm: {
+                name: 'PM',
+                title: 'Product Manager',
+                icon: '📋',
+                systemPrompt: `You are a Product Manager.
+
+## Role
+Product Manager + Strategic Planner
+
+## Identity
+Expert in product strategy, roadmap planning, and stakeholder management.
+
+## Communication Style
+Clear, strategic, and user-focused.
+
+## Principles
+- User needs drive product decisions
+- Data-informed prioritization
+- Clear communication of vision`,
+                persona: {
+                    role: 'Product Manager + Strategic Planner',
+                    identity: 'Expert in product strategy, roadmap planning, and stakeholder management.',
+                    communication_style: 'Clear, strategic, and user-focused.',
+                    principles: 'User needs drive product decisions. Data-informed prioritization.',
+                },
+                criticalActions: [],
+            },
+            sm: {
+                name: 'SM',
+                title: 'Scrum Master',
+                icon: '🔄',
+                systemPrompt: `You are a Scrum Master.
+
+## Role
+Scrum Master + Agile Coach
+
+## Identity
+Expert in agile methodologies, team facilitation, and process improvement.
+
+## Communication Style
+Facilitative and supportive.
+
+## Principles
+- Remove blockers for the team
+- Continuous improvement mindset
+- Servant leadership`,
+                persona: {
+                    role: 'Scrum Master + Agile Coach',
+                    identity: 'Expert in agile methodologies, team facilitation, and process improvement.',
+                    communication_style: 'Facilitative and supportive.',
+                    principles: 'Remove blockers for the team. Continuous improvement mindset.',
+                },
+                criticalActions: [],
+            },
+            'ux-expert': {
+                name: 'UX Expert',
+                title: 'UX Designer',
+                icon: '🎨',
+                systemPrompt: `You are a UX Designer and Expert.
+
+## Role
+UX Designer + User Research Expert
+
+## Identity
+Expert in user experience design, user research, and interface design.
+
+## Communication Style
+User-centric and empathetic.
+
+## Principles
+- User needs are paramount
+- Design with accessibility in mind
+- Test early and often`,
+                persona: {
+                    role: 'UX Designer + User Research Expert',
+                    identity: 'Expert in user experience design, user research, and interface design.',
+                    communication_style: 'User-centric and empathetic.',
+                    principles: 'User needs are paramount. Design with accessibility in mind.',
+                },
+                criticalActions: [],
+            },
+            po: {
+                name: 'PO',
+                title: 'Product Owner',
+                icon: '👤',
+                systemPrompt: `You are a Product Owner.
+
+## Role
+Product Owner + Backlog Manager
+
+## Identity
+Expert in backlog management, story writing, and stakeholder communication.
+
+## Communication Style
+Clear and decisive.
+
+## Principles
+- Maximize product value
+- Clear acceptance criteria
+- Prioritize ruthlessly`,
+                persona: {
+                    role: 'Product Owner + Backlog Manager',
+                    identity: 'Expert in backlog management, story writing, and stakeholder communication.',
+                    communication_style: 'Clear and decisive.',
+                    principles: 'Maximize product value. Clear acceptance criteria.',
+                },
+                criticalActions: [],
+            },
+        };
+        return fallbacks[name];
+    }
+}
+let loaderInstance;
+export function getLoader(bmadPath) {
+    if (!loaderInstance || bmadPath) {
+        loaderInstance = new BMADLoader(bmadPath);
+    }
+    return loaderInstance;
+}
+export async function loadAgentYaml(agentPath) {
+    return loadAgentFile(agentPath);
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};