aided-dev 1.0.0

package/dist/agent-creator/creator.js

@@ -0,0 +1,393 @@
+import Anthropic from '@anthropic-ai/sdk';
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+import { getApiKey } from '../config.js';
+import { getLoader, buildSystemPrompt } from '../bmad/index.js';
+export class AgentCreator {
+    client;
+    model;
+    outputDir;
+    verbose;
+    conversationHistory = [];
+    constructor(options = {}) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new Error('API key not configured. Run: aidev config --api-key <key>');
+        }
+        this.client = new Anthropic({ apiKey });
+        this.model = options.model || 'claude-sonnet-4-20250514';
+        this.outputDir = options.outputDir || process.cwd();
+        this.verbose = options.verbose || false;
+    }
+    async buildAgentBuilderPrompt() {
+        const loader = getLoader();
+        if (loader.isAvailable()) {
+            const agentBuilderPath = path.join(loader.getPath(), 'src/modules/bmb/agents/agent-builder.agent.yaml');
+            if (fs.existsSync(agentBuilderPath)) {
+                try {
+                    const content = fs.readFileSync(agentBuilderPath, 'utf-8');
+                    const parsed = yaml.load(content);
+                    if (parsed?.agent) {
+                        return buildSystemPrompt(parsed.agent) + this.getAgentCreationInstructions();
+                    }
+                }
+                catch (error) {
+                    if (this.verbose) {
+                        console.log(chalk.dim('Could not load agent-builder, using fallback'));
+                    }
+                }
+            }
+        }
+        return this.getFallbackAgentBuilderPrompt();
+    }
+    getAgentCreationInstructions() {
+        return `
+
+## Your Task
+
+You are helping the user create a new BMAD-compliant agent. Guide them through these steps:
+
+### Step 1: Brainstorming
+Ask about:
+- What problem should this agent solve?
+- What domain expertise should it have?
+- What's the target user?
+
+### Step 2: Metadata
+Help define:
+- **name**: A short, memorable name (like Mary, Winston, Bond)
+- **title**: Professional title (like Business Analyst, Agent Building Expert)
+- **icon**: A single emoji that represents the agent
+- **id**: A unique identifier path
+
+### Step 3: Persona
+Craft together:
+- **role**: The agent's primary function and expertise areas
+- **identity**: Background, experience, and specialization
+- **communication_style**: How the agent speaks and interacts
+- **principles**: Core rules and guidelines the agent follows
+
+### Step 4: Menu Commands (optional)
+Define any commands the agent should support with:
+- **trigger**: Short code and fuzzy match pattern
+- **description**: What the command does
+
+### Step 5: Output
+When complete, output the agent definition in YAML format between \`\`\`yaml and \`\`\` markers.
+
+Start by introducing yourself and asking about the agent they want to create.`;
+    }
+    getFallbackAgentBuilderPrompt() {
+        return `You are Bond, the Agent Building Expert.
+
+## Role
+Agent Architecture Specialist + BMAD Compliance Expert
+
+## Identity
+Master agent architect with deep expertise in agent design patterns, persona development, and BMAD Core compliance. Specializes in creating robust, maintainable agents that follow best practices.
+
+## Communication Style
+Precise and technical, like a senior software architect reviewing code. Focuses on structure, compliance, and long-term maintainability. Uses agent-specific terminology and framework references.
+
+## Principles
+- Every agent must follow BMAD Core standards and best practices
+- Personas drive agent behavior - make them specific and authentic
+- Menu structure must be consistent across all agents
+- Validate compliance before finalizing any agent
+- Focus on practical implementation and real-world usage
+${this.getAgentCreationInstructions()}`;
+    }
+    async chat(userMessage, systemPrompt) {
+        this.conversationHistory.push({
+            role: 'user',
+            content: userMessage,
+        });
+        const response = await this.client.messages.create({
+            model: this.model,
+            max_tokens: 4096,
+            system: systemPrompt,
+            messages: this.conversationHistory,
+        });
+        const assistantMessage = response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('\n');
+        this.conversationHistory.push({
+            role: 'assistant',
+            content: assistantMessage,
+        });
+        return assistantMessage;
+    }
+    extractYaml(response) {
+        const yamlMatch = response.match(/```yaml\n([\s\S]*?)\n```/);
+        if (yamlMatch) {
+            return yamlMatch[1];
+        }
+        return null;
+    }
+    parseAgentDefinition(yamlContent) {
+        try {
+            const parsed = yaml.load(yamlContent);
+            const agent = parsed.agent || parsed;
+            if (!agent.metadata?.name || !agent.metadata?.title || !agent.persona?.role) {
+                return null;
+            }
+            return agent;
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveAgent(agent) {
+        const filename = `${agent.metadata.name.toLowerCase().replace(/\s+/g, '-')}.agent.yaml`;
+        const filepath = path.join(this.outputDir, filename);
+        const content = `# ${agent.metadata.title} Agent Definition
+# Created with aidev agent-builder
+
+agent:
+  metadata:
+    id: "${agent.metadata.id}"
+    name: ${agent.metadata.name}
+    title: ${agent.metadata.title}
+    icon: ${agent.metadata.icon}
+    hasSidecar: ${agent.metadata.hasSidecar || false}
+
+  persona:
+    role: ${agent.metadata.name}'s role as ${agent.persona.role}
+    identity: ${agent.persona.identity}
+    communication_style: "${agent.persona.communication_style}"
+    principles: |
+${agent.persona.principles.split('\n').map(line => `      ${line}`).join('\n')}
+${agent.menu && agent.menu.length > 0 ? `
+  menu:
+${agent.menu.map(item => `    - trigger: ${item.trigger}
+      ${item.exec ? `exec: "${item.exec}"` : item.workflow ? `workflow: "${item.workflow}"` : ''}
+      description: "${item.description}"`).join('\n')}` : ''}
+`;
+        fs.writeFileSync(filepath, content, 'utf-8');
+        return filepath;
+    }
+    async create() {
+        console.log('');
+        p.intro(chalk.bgMagenta.white(' 🤖 Agent Builder (Bond) '));
+        const systemPrompt = await this.buildAgentBuilderPrompt();
+        const intro = await this.chat('I want to create a new BMAD agent. Please guide me through the process.', systemPrompt);
+        console.log('');
+        console.log(chalk.cyan('Bond:'));
+        console.log(intro);
+        console.log('');
+        let agentCreated = false;
+        let extractedAgent = null;
+        while (!agentCreated) {
+            const userInput = await p.text({
+                message: 'You:',
+                placeholder: 'Type your response (or "done" to finish, "cancel" to exit)',
+            });
+            if (p.isCancel(userInput)) {
+                p.cancel('Agent creation cancelled');
+                return;
+            }
+            const input = userInput.trim().toLowerCase();
+            if (input === 'cancel' || input === 'exit' || input === 'quit') {
+                p.cancel('Agent creation cancelled');
+                return;
+            }
+            const spinner = p.spinner();
+            spinner.start('Bond is thinking...');
+            const response = await this.chat(userInput, systemPrompt);
+            spinner.stop('');
+            console.log('');
+            console.log(chalk.cyan('Bond:'));
+            console.log(response);
+            console.log('');
+            const yamlContent = this.extractYaml(response);
+            if (yamlContent) {
+                extractedAgent = this.parseAgentDefinition(yamlContent);
+                if (extractedAgent) {
+                    console.log('');
+                    console.log(chalk.green('✓ Agent definition extracted!'));
+                    console.log('');
+                    const confirm = await p.confirm({
+                        message: `Save agent "${extractedAgent.metadata.name}" to ${this.outputDir}?`,
+                    });
+                    if (p.isCancel(confirm) || !confirm) {
+                        console.log(chalk.yellow('Agent not saved. You can continue refining or type "cancel" to exit.'));
+                    }
+                    else {
+                        const filepath = await this.saveAgent(extractedAgent);
+                        console.log('');
+                        console.log(chalk.green(`✓ Agent saved to: ${filepath}`));
+                        agentCreated = true;
+                    }
+                }
+            }
+            if (input === 'done' || input === 'finish' || input === 'complete') {
+                if (!extractedAgent) {
+                    const finalPrompt = await this.chat('Please generate the final YAML definition for the agent we discussed.', systemPrompt);
+                    console.log('');
+                    console.log(chalk.cyan('Bond:'));
+                    console.log(finalPrompt);
+                    console.log('');
+                    const finalYaml = this.extractYaml(finalPrompt);
+                    if (finalYaml) {
+                        extractedAgent = this.parseAgentDefinition(finalYaml);
+                        if (extractedAgent) {
+                            const filepath = await this.saveAgent(extractedAgent);
+                            console.log('');
+                            console.log(chalk.green(`✓ Agent saved to: ${filepath}`));
+                            agentCreated = true;
+                        }
+                    }
+                }
+                if (!agentCreated) {
+                    console.log(chalk.yellow('Could not extract agent definition. Continue the conversation or type "cancel" to exit.'));
+                }
+            }
+        }
+        p.outro(chalk.green('Agent creation complete! 🎉'));
+    }
+}
+export async function quickCreateAgent(options = {}) {
+    console.log('');
+    p.intro(chalk.bgMagenta.white(' 🤖 Quick Agent Creator '));
+    const name = await p.text({
+        message: 'Agent name (short, memorable):',
+        placeholder: 'e.g., Max, Luna, Atlas',
+        validate: (value) => {
+            if (!value)
+                return 'Name is required';
+            if (value.length > 20)
+                return 'Name should be short (max 20 chars)';
+            return undefined;
+        },
+    });
+    if (p.isCancel(name)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const title = await p.text({
+        message: 'Professional title:',
+        placeholder: 'e.g., Code Review Expert, Documentation Specialist',
+        validate: (value) => {
+            if (!value)
+                return 'Title is required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(title)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const icon = await p.text({
+        message: 'Icon (single emoji):',
+        placeholder: '🤖',
+        initialValue: '🤖',
+        validate: (value) => {
+            if (!value)
+                return 'Icon is required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(icon)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const role = await p.text({
+        message: 'Role and expertise:',
+        placeholder: 'e.g., Senior Code Reviewer + Quality Assurance Expert',
+        validate: (value) => {
+            if (!value)
+                return 'Role is required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(role)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const identity = await p.text({
+        message: 'Identity (background and specialization):',
+        placeholder: 'Describe experience and expertise...',
+        validate: (value) => {
+            if (!value)
+                return 'Identity is required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(identity)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const style = await p.text({
+        message: 'Communication style:',
+        placeholder: 'e.g., Direct and technical, with a focus on actionable feedback',
+        validate: (value) => {
+            if (!value)
+                return 'Style is required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(style)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const principles = await p.text({
+        message: 'Key principles (comma-separated):',
+        placeholder: 'e.g., Always explain why, Suggest improvements, Be constructive',
+        validate: (value) => {
+            if (!value)
+                return 'Principles are required';
+            return undefined;
+        },
+    });
+    if (p.isCancel(principles)) {
+        p.cancel('Cancelled');
+        return;
+    }
+    const agent = {
+        metadata: {
+            id: `custom/agents/${name.toLowerCase().replace(/\s+/g, '-')}.md`,
+            name: name,
+            title: title,
+            icon: icon,
+            hasSidecar: false,
+        },
+        persona: {
+            role: role,
+            identity: identity,
+            communication_style: style,
+            principles: principles
+                .split(',')
+                .map((p) => `- ${p.trim()}`)
+                .join('\n'),
+        },
+    };
+    const outputDir = options.outputDir || process.cwd();
+    const filename = `${agent.metadata.name.toLowerCase().replace(/\s+/g, '-')}.agent.yaml`;
+    const filepath = path.join(outputDir, filename);
+    const content = `# ${agent.metadata.title} Agent Definition
+# Created with aidev quick-create
+
+agent:
+  metadata:
+    id: "${agent.metadata.id}"
+    name: ${agent.metadata.name}
+    title: ${agent.metadata.title}
+    icon: ${agent.metadata.icon}
+    hasSidecar: false
+
+  persona:
+    role: ${agent.persona.role}
+    identity: ${agent.persona.identity}
+    communication_style: "${agent.persona.communication_style}"
+    principles: |
+${agent.persona.principles.split('\n').map(line => `      ${line}`).join('\n')}
+`;
+    fs.writeFileSync(filepath, content, 'utf-8');
+    console.log('');
+    console.log(chalk.green(`✓ Agent saved to: ${filepath}`));
+    p.outro(chalk.green('Agent created! 🎉'));
+}

package/dist/agent-creator/index.d.ts

@@ -0,0 +1 @@
+export { AgentCreator, quickCreateAgent, type AgentCreatorOptions } from './creator.js';

package/dist/agent-creator/index.js

@@ -0,0 +1 @@
+export { AgentCreator, quickCreateAgent } from './creator.js';

package/dist/bmad/index.d.ts

@@ -0,0 +1 @@
+export { BMADLoader, getLoader, findBMADPath, loadAgentYaml, buildSystemPrompt, toAgentConfig, type BMADAgent, type AgentConfig, type AgentMetadata, type AgentPersona, type AgentMenuItem, } from './loader.js';

package/dist/bmad/index.js

@@ -0,0 +1 @@
+export { BMADLoader, getLoader, findBMADPath, loadAgentYaml, buildSystemPrompt, toAgentConfig, } from './loader.js';

package/dist/bmad/loader.d.ts

@@ -0,0 +1,68 @@
+export interface AgentMetadata {
+    id: string;
+    name: string;
+    title: string;
+    icon: string;
+    module?: string;
+    hasSidecar?: boolean;
+    whenToUse?: string;
+}
+export interface AgentPersona {
+    role: string;
+    identity: string;
+    communication_style?: string;
+    style?: string;
+    focus?: string;
+    principles?: string;
+    core_principles?: string[];
+}
+export interface AgentMenuItem {
+    trigger: string;
+    workflow?: string;
+    exec?: string;
+    data?: string;
+    description: string;
+}
+export interface BMADAgent {
+    metadata?: AgentMetadata;
+    agent?: {
+        name: string;
+        id: string;
+        title: string;
+        icon: string;
+        whenToUse?: string;
+    };
+    persona: AgentPersona;
+    critical_actions?: string[];
+    commands?: string[];
+    menu?: AgentMenuItem[];
+}
+export interface AgentConfig {
+    name: string;
+    title: string;
+    icon: string;
+    systemPrompt: string;
+    persona: AgentPersona;
+    criticalActions: string[];
+}
+export declare function findBMADPath(): string | undefined;
+export declare function loadAgentFile(filePath: string): Promise<BMADAgent | undefined>;
+export declare function buildSystemPrompt(agent: BMADAgent): string;
+export declare function toAgentConfig(agent: BMADAgent): AgentConfig;
+export declare class BMADLoader {
+    private bmadPath;
+    private agentsPaths;
+    private agentCache;
+    private formatType;
+    constructor(bmadPath?: string);
+    isAvailable(): boolean;
+    getPath(): string | undefined;
+    getFormatType(): 'npm' | 'local' | 'unknown';
+    listAgents(): Promise<string[]>;
+    loadAgent(name: string): Promise<AgentConfig | undefined>;
+    loadAgents(names: string[]): Promise<Map<string, AgentConfig>>;
+    getLoadedAgents(): Map<string, AgentConfig>;
+    private getFallbackAgent;
+}
+export declare function getLoader(bmadPath?: string): BMADLoader;
+export declare function loadAgentYaml(agentPath: string): Promise<BMADAgent | undefined>;