aided-dev 1.0.0

package/dist/discovery/documents.js

@@ -0,0 +1,154 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { glob } from 'glob';
+export const PROJECT_DOC_PATTERNS = {
+    brownfieldArchitecture: '{project}-brownfield-architecture.md',
+    integrationMap: '{project}-integration-map.md',
+    systemAnalysis: '{project}-system-analysis.md',
+};
+const DOC_LOCATIONS = ['', 'docs/', 'doc/', 'documentation/', '.aidev/'];
+export async function detectProjectName(repoPath) {
+    const packageJsonPath = path.join(repoPath, 'package.json');
+    if (await fs.pathExists(packageJsonPath)) {
+        try {
+            const pkg = await fs.readJson(packageJsonPath);
+            if (pkg.name) {
+                return pkg.name.replace('@', '').replace('/', '-');
+            }
+        }
+        catch {
+        }
+    }
+    const pyprojectPath = path.join(repoPath, 'pyproject.toml');
+    if (await fs.pathExists(pyprojectPath)) {
+        try {
+            const content = await fs.readFile(pyprojectPath, 'utf-8');
+            const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+            if (nameMatch) {
+                return nameMatch[1];
+            }
+        }
+        catch {
+        }
+    }
+    const cargoPath = path.join(repoPath, 'Cargo.toml');
+    if (await fs.pathExists(cargoPath)) {
+        try {
+            const content = await fs.readFile(cargoPath, 'utf-8');
+            const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+            if (nameMatch) {
+                return nameMatch[1];
+            }
+        }
+        catch {
+        }
+    }
+    const goModPath = path.join(repoPath, 'go.mod');
+    if (await fs.pathExists(goModPath)) {
+        try {
+            const content = await fs.readFile(goModPath, 'utf-8');
+            const moduleMatch = content.match(/module\s+(\S+)/);
+            if (moduleMatch) {
+                const parts = moduleMatch[1].split('/');
+                return parts[parts.length - 1];
+            }
+        }
+        catch {
+        }
+    }
+    return path.basename(repoPath);
+}
+export async function findProjectNameFromDocs(repoPath) {
+    const patterns = [
+        '*-brownfield-architecture.md',
+        '*-integration-map.md',
+        '*-system-analysis.md',
+    ];
+    for (const location of DOC_LOCATIONS) {
+        const searchPath = path.join(repoPath, location);
+        if (!(await fs.pathExists(searchPath)))
+            continue;
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, { cwd: searchPath });
+            if (matches.length > 0) {
+                const filename = path.basename(matches[0], '.md');
+                for (const suffix of ['-brownfield-architecture', '-integration-map', '-system-analysis']) {
+                    if (filename.endsWith(suffix)) {
+                        return filename.slice(0, -suffix.length);
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export async function discoverProjectDocuments(repoPath) {
+    let projectName = await detectProjectName(repoPath);
+    if (!projectName) {
+        projectName = await findProjectNameFromDocs(repoPath);
+    }
+    if (!projectName) {
+        return undefined;
+    }
+    const docs = {
+        projectName,
+    };
+    for (const location of DOC_LOCATIONS) {
+        const basePath = path.join(repoPath, location);
+        if (!(await fs.pathExists(basePath)))
+            continue;
+        if (!docs.brownfieldArchitecture) {
+            const archPath = path.join(basePath, `${projectName}-brownfield-architecture.md`);
+            if (await fs.pathExists(archPath)) {
+                docs.brownfieldArchitecture = {
+                    path: archPath,
+                    content: await fs.readFile(archPath, 'utf-8'),
+                };
+            }
+        }
+        if (!docs.integrationMap) {
+            const intPath = path.join(basePath, `${projectName}-integration-map.md`);
+            if (await fs.pathExists(intPath)) {
+                docs.integrationMap = {
+                    path: intPath,
+                    content: await fs.readFile(intPath, 'utf-8'),
+                };
+            }
+        }
+        if (!docs.systemAnalysis) {
+            const sysPath = path.join(basePath, `${projectName}-system-analysis.md`);
+            if (await fs.pathExists(sysPath)) {
+                docs.systemAnalysis = {
+                    path: sysPath,
+                    content: await fs.readFile(sysPath, 'utf-8'),
+                };
+            }
+        }
+    }
+    if (docs.brownfieldArchitecture || docs.integrationMap || docs.systemAnalysis) {
+        return docs;
+    }
+    return undefined;
+}
+export function hasDocuments(docs) {
+    if (!docs)
+        return false;
+    return !!(docs.brownfieldArchitecture || docs.integrationMap || docs.systemAnalysis);
+}
+export function formatDocumentsForPrompt(docs) {
+    const parts = [];
+    parts.push(`## Project Source of Truth: ${docs.projectName}`);
+    if (docs.brownfieldArchitecture) {
+        parts.push('\n### Brownfield Architecture');
+        parts.push(docs.brownfieldArchitecture.content);
+    }
+    if (docs.integrationMap) {
+        parts.push('\n### Integration Map');
+        parts.push(docs.integrationMap.content);
+    }
+    if (docs.systemAnalysis) {
+        parts.push('\n### System Analysis');
+        parts.push(docs.systemAnalysis.content);
+    }
+    return parts.join('\n');
+}

package/dist/discovery/index.d.ts

@@ -0,0 +1,2 @@
+export { discoverProjectDocuments, detectProjectName, findProjectNameFromDocs, hasDocuments, formatDocumentsForPrompt, PROJECT_DOC_PATTERNS, type ProjectDocuments, } from './documents.js';
+export { detectStack, formatStack, type ProjectStack, } from './detector.js';

package/dist/discovery/index.js

@@ -0,0 +1,2 @@
+export { discoverProjectDocuments, detectProjectName, findProjectNameFromDocs, hasDocuments, formatDocumentsForPrompt, PROJECT_DOC_PATTERNS, } from './documents.js';
+export { detectStack, formatStack, } from './detector.js';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { Orchestrator, TaskPlanner, AGENT_CAPABILITIES, type OrchestratorOptions, type WorkflowState, type ExecutionPlan, type PlannedStep, type TaskType, } from './orchestrator/index.js';
+export { BMADLoader, getLoader, findBMADPath, buildSystemPrompt, type AgentConfig, type BMADAgent, type AgentMetadata, type AgentPersona, } from './bmad/index.js';
+export { discoverProjectDocuments, detectStack, formatDocumentsForPrompt, formatStack, PROJECT_DOC_PATTERNS, type ProjectDocuments, type ProjectStack, } from './discovery/index.js';
+export { getConfig, getApiKey, setApiKey, hasApiKey, getConfigPath, } from './config.js';
+export { AgentCreator, quickCreateAgent, type AgentCreatorOptions, } from './agent-creator/index.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export { Orchestrator, TaskPlanner, AGENT_CAPABILITIES, } from './orchestrator/index.js';
+export { BMADLoader, getLoader, findBMADPath, buildSystemPrompt, } from './bmad/index.js';
+export { discoverProjectDocuments, detectStack, formatDocumentsForPrompt, formatStack, PROJECT_DOC_PATTERNS, } from './discovery/index.js';
+export { getConfig, getApiKey, setApiKey, hasApiKey, getConfigPath, } from './config.js';
+export { AgentCreator, quickCreateAgent, } from './agent-creator/index.js';

package/dist/orchestrator/index.d.ts

@@ -0,0 +1,3 @@
+export { Orchestrator, type OrchestratorOptions, type WorkflowState } from './orchestrator.js';
+export { TaskPlanner, AGENT_CAPABILITIES, type ExecutionPlan, type PlannedStep, type TaskType, } from './planner.js';
+export { BMADLoader, getLoader, type AgentConfig } from '../bmad/index.js';

package/dist/orchestrator/index.js

@@ -0,0 +1,3 @@
+export { Orchestrator } from './orchestrator.js';
+export { TaskPlanner, AGENT_CAPABILITIES, } from './planner.js';
+export { BMADLoader, getLoader } from '../bmad/index.js';

package/dist/orchestrator/orchestrator.d.ts

@@ -0,0 +1,40 @@
+import { type ProjectDocuments, type ProjectStack } from '../discovery/index.js';
+import { type ExecutionPlan } from './planner.js';
+export interface OrchestratorOptions {
+    repoPath: string;
+    model?: string;
+    verbose?: boolean;
+    skipPlanning?: boolean;
+}
+export interface WorkflowState {
+    task: string;
+    repoPath: string;
+    projectDocuments?: ProjectDocuments;
+    stack?: ProjectStack;
+    plan?: ExecutionPlan;
+    outputs: Map<string, string>;
+    errors: string[];
+}
+export declare class Orchestrator {
+    private client;
+    private model;
+    private repoPath;
+    private verbose;
+    private skipPlanning;
+    private bmadLoader;
+    private agents;
+    private planner;
+    constructor(options: OrchestratorOptions);
+    private loadAgents;
+    private getAgent;
+    run(task: string): Promise<WorkflowState>;
+    private phaseDiscover;
+    private phasePlanning;
+    private executeplan;
+    private executeStep;
+    private buildContext;
+    private formatOutputTitle;
+    private buildStepPrompt;
+    private extractTextContent;
+    private printSummary;
+}

package/dist/orchestrator/orchestrator.js

@@ -0,0 +1,386 @@
+import Anthropic from '@anthropic-ai/sdk';
+import ora from 'ora';
+import chalk from 'chalk';
+import { discoverProjectDocuments, detectStack, formatDocumentsForPrompt, formatStack, } from '../discovery/index.js';
+import { getLoader } from '../bmad/index.js';
+import { getApiKey } from '../config.js';
+import { TaskPlanner, AGENT_CAPABILITIES, } from './planner.js';
+export class Orchestrator {
+    client;
+    model;
+    repoPath;
+    verbose;
+    skipPlanning;
+    bmadLoader;
+    agents = new Map();
+    planner = null;
+    constructor(options) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new Error('Anthropic API key not found. Run `aidev config --api-key <key>` or set ANTHROPIC_API_KEY environment variable.');
+        }
+        this.client = new Anthropic({ apiKey });
+        this.model = options.model || 'claude-sonnet-4-20250514';
+        this.repoPath = options.repoPath;
+        this.verbose = options.verbose || false;
+        this.skipPlanning = options.skipPlanning || false;
+        this.bmadLoader = getLoader();
+    }
+    async loadAgents() {
+        const allAgentNames = await this.bmadLoader.listAgents();
+        const coreAgents = ['analyst', 'architect', 'dev', 'tea', 'pm', 'sm', 'tech-writer', 'ux-designer'];
+        const agentNames = [...new Set([...allAgentNames, ...coreAgents])];
+        this.agents = await this.bmadLoader.loadAgents(agentNames);
+        if (this.bmadLoader.isAvailable()) {
+            console.log(chalk.dim(`  BMAD-METHOD: ${this.bmadLoader.getPath()}`));
+            console.log(chalk.dim(`  Loaded ${this.agents.size} agents`));
+        }
+        else {
+            console.log(chalk.dim('  BMAD-METHOD: Using fallback agents'));
+        }
+        this.planner = new TaskPlanner(this.client, this.model, this.agents);
+    }
+    getAgent(name) {
+        const nameMap = {
+            analyst: 'analyst',
+            architect: 'architect',
+            developer: 'dev',
+            dev: 'dev',
+            qa: 'tea',
+            tea: 'tea',
+            'tech-writer': 'tech-writer',
+            'ux-designer': 'ux-designer',
+            pm: 'pm',
+            sm: 'sm',
+        };
+        const bmadName = nameMap[name] || name;
+        return this.agents.get(bmadName);
+    }
+    async run(task) {
+        const state = {
+            task,
+            repoPath: this.repoPath,
+            outputs: new Map(),
+            errors: [],
+        };
+        console.log('');
+        console.log(chalk.bgBlue.white(' AI Dev Team - Smart Orchestration '));
+        console.log(chalk.dim(`Task: ${task}`));
+        console.log('');
+        await this.loadAgents();
+        await this.phaseDiscover(state);
+        if (state.errors.length > 0) {
+            this.printSummary(state);
+            return state;
+        }
+        await this.phasePlanning(state);
+        if (state.errors.length > 0 || !state.plan) {
+            this.printSummary(state);
+            return state;
+        }
+        await this.executeplan(state);
+        this.printSummary(state);
+        return state;
+    }
+    async phaseDiscover(state) {
+        const spinner = ora('Discovering project context...').start();
+        try {
+            state.stack = await detectStack(this.repoPath);
+            spinner.text = `Detected: ${state.stack.language}`;
+            state.projectDocuments = await discoverProjectDocuments(this.repoPath);
+            spinner.succeed(chalk.green('Discovery complete'));
+            console.log(chalk.dim(`  Language: ${state.stack.language}`));
+            if (state.stack.framework) {
+                console.log(chalk.dim(`  Framework: ${state.stack.framework}`));
+            }
+            if (state.projectDocuments) {
+                const docCount = [
+                    state.projectDocuments.brownfieldArchitecture,
+                    state.projectDocuments.integrationMap,
+                    state.projectDocuments.systemAnalysis,
+                ].filter(Boolean).length;
+                console.log(chalk.green(`  Found ${docCount} source-of-truth document(s)`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Discovery failed'));
+            state.errors.push(`Discovery error: ${error}`);
+        }
+    }
+    async phasePlanning(state) {
+        if (!this.planner) {
+            state.errors.push('Planner not initialized');
+            return;
+        }
+        const spinner = ora('Analyzing task and creating execution plan...').start();
+        try {
+            const plan = await this.planner.createPlan(state.task, {
+                stack: state.stack,
+                hasProjectDocs: !!state.projectDocuments,
+                existingCode: state.stack?.language !== 'unknown',
+            });
+            const validation = this.planner.validatePlan(plan);
+            if (!validation.valid) {
+                spinner.warn(chalk.yellow('Plan has issues, adjusting...'));
+                if (this.verbose) {
+                    validation.errors.forEach((e) => console.log(chalk.dim(`  - ${e}`)));
+                }
+            }
+            state.plan = plan;
+            spinner.succeed(chalk.green('Execution plan created'));
+            console.log('');
+            console.log(chalk.cyan(`Task Type: ${plan.taskType}`));
+            console.log(chalk.cyan(`Complexity: ${plan.estimatedComplexity}`));
+            console.log(chalk.dim(`Reasoning: ${plan.reasoning}`));
+            console.log('');
+            console.log(chalk.bold('Execution Plan:'));
+            for (let i = 0; i < plan.steps.length; i++) {
+                const step = plan.steps[i];
+                const agent = this.getAgent(step.agent);
+                const agentInfo = AGENT_CAPABILITIES[step.agent];
+                const icon = agent?.icon || '🤖';
+                const name = agent?.name || agentInfo?.name || step.agent;
+                const priorityIcon = step.priority === 'required' ? '●' :
+                    step.priority === 'recommended' ? '◐' : '○';
+                console.log(chalk.dim(`  ${i + 1}. ${priorityIcon} ${icon} ${name}: ${step.action}`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Planning failed'));
+            state.errors.push(`Planning error: ${error}`);
+        }
+    }
+    async executeplan(state) {
+        if (!state.plan)
+            return;
+        for (const step of state.plan.steps) {
+            const missingDeps = step.dependsOn.filter((dep) => !state.outputs.has(dep));
+            if (missingDeps.length > 0 && step.priority === 'required') {
+                state.errors.push(`Cannot execute ${step.outputKey}: missing dependencies ${missingDeps.join(', ')}`);
+                continue;
+            }
+            await this.executeStep(step, state);
+            if (step.priority === 'required' &&
+                !state.outputs.has(step.outputKey) &&
+                state.errors.length > 0) {
+                break;
+            }
+        }
+    }
+    async executeStep(step, state) {
+        const agent = this.getAgent(step.agent);
+        if (!agent) {
+            if (step.priority === 'required') {
+                state.errors.push(`Agent '${step.agent}' not available`);
+            }
+            return;
+        }
+        const spinner = ora(`${agent.icon} ${agent.name} (${agent.title}): ${step.action}...`).start();
+        try {
+            const context = this.buildContext(state, step);
+            const prompt = this.buildStepPrompt(step, state);
+            const response = await this.client.messages.create({
+                model: this.model,
+                max_tokens: 8192,
+                system: agent.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `${context}\n\n${prompt}`,
+                    },
+                ],
+            });
+            const output = this.extractTextContent(response);
+            state.outputs.set(step.outputKey, output);
+            spinner.succeed(chalk.green(`${agent.icon} ${step.action} complete`));
+            if (this.verbose) {
+                console.log(chalk.dim(`\n--- ${step.outputKey} Output ---`));
+                console.log(chalk.dim(output.substring(0, 500) + '...'));
+                console.log('');
+            }
+        }
+        catch (error) {
+            const errorMsg = `${step.action} failed: ${error}`;
+            if (step.priority === 'optional') {
+                spinner.warn(chalk.yellow(`${agent.icon} ${step.action} skipped (optional)`));
+            }
+            else if (step.priority === 'recommended') {
+                spinner.warn(chalk.yellow(`${agent.icon} ${step.action} failed (non-blocking)`));
+            }
+            else {
+                spinner.fail(chalk.red(`${agent.icon} ${step.action} failed`));
+                state.errors.push(errorMsg);
+            }
+        }
+    }
+    buildContext(state, step) {
+        const parts = [];
+        if (state.stack) {
+            parts.push('## Project Stack');
+            parts.push(formatStack(state.stack));
+        }
+        if (state.projectDocuments) {
+            parts.push('\n' + formatDocumentsForPrompt(state.projectDocuments));
+        }
+        for (const dep of step.dependsOn) {
+            const depOutput = state.outputs.get(dep);
+            if (depOutput) {
+                parts.push(`\n## ${this.formatOutputTitle(dep)}`);
+                parts.push(depOutput);
+            }
+        }
+        return parts.join('\n');
+    }
+    formatOutputTitle(key) {
+        return key
+            .replace(/_/g, ' ')
+            .replace(/\b\w/g, (c) => c.toUpperCase());
+    }
+    buildStepPrompt(step, state) {
+        const task = state.task;
+        const promptTemplates = {
+            prd: `## Task
+${task}
+
+## Instructions
+Create a Product Requirements Document (PRD) for this task. Include:
+1. Project overview and goals
+2. Core features (prioritized)
+3. User stories with acceptance criteria
+4. Out of scope items
+5. Success metrics
+6. Technical constraints
+
+Respond in a structured markdown format.`,
+            architecture: `## Task
+${task}
+
+## Instructions
+Design the technical architecture for this project. Include:
+1. Tech stack selection with justification
+2. File/folder structure
+3. API design (endpoints, methods, request/response)
+4. Data models
+5. Framework patterns to follow
+6. Configuration requirements
+
+Consider the existing project context and follow established patterns.
+Respond in a structured markdown format with code blocks where appropriate.`,
+            implementation: `## Task
+${task}
+
+## Instructions
+Implement the code according to the specifications provided.
+- Follow the architecture/design if provided
+- Implement all required functionality
+- Include proper error handling
+- Add inline documentation
+- Follow framework conventions
+
+Output each file with its path and complete code.`,
+            tests: `## Task
+${task}
+
+## Instructions
+Generate comprehensive tests for the implementation:
+- Unit tests for core functions
+- Integration tests for API endpoints
+- Edge cases and error scenarios
+- Use appropriate test framework for the stack
+
+Output test files with paths and complete test code.`,
+            fix: `## Task
+${task}
+
+## Instructions
+Analyze and fix the reported issue:
+1. Identify the root cause
+2. Implement the fix
+3. Ensure no regressions
+4. Document the changes
+
+Output the fixed code with explanations.`,
+            design: `## Task
+${task}
+
+## Instructions
+Create a design document for this task:
+1. Analyze current state
+2. Propose improvements
+3. Define the approach
+4. List changes needed
+
+Respond in a structured markdown format.`,
+            docs: `## Task
+${task}
+
+## Instructions
+Create documentation for this task:
+1. Overview and purpose
+2. Usage instructions
+3. API reference (if applicable)
+4. Examples
+5. Troubleshooting
+
+Use clear, technical writing style.`,
+            analysis: `## Task
+${task}
+
+## Instructions
+Analyze the requirements and provide:
+1. Problem breakdown
+2. Key considerations
+3. Recommendations
+4. Risks and mitigations
+
+Be thorough and specific.`,
+        };
+        const templateKey = Object.keys(promptTemplates).find((key) => step.outputKey.includes(key) || step.action.toLowerCase().includes(key));
+        if (templateKey) {
+            return promptTemplates[templateKey];
+        }
+        return `## Task
+${task}
+
+## Your Action
+${step.action}
+
+## Instructions
+${step.description}
+
+Provide your output in a clear, structured format.`;
+    }
+    extractTextContent(response) {
+        return response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('\n');
+    }
+    printSummary(state) {
+        console.log('');
+        if (state.errors.length > 0) {
+            console.log(chalk.red('Workflow completed with errors:'));
+            for (const error of state.errors) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+        }
+        else {
+            console.log(chalk.green('✓ Workflow complete!'));
+        }
+        if (state.outputs.size > 0) {
+            console.log('');
+            console.log(chalk.dim('Outputs generated:'));
+            for (const key of state.outputs.keys()) {
+                console.log(chalk.dim(`  - ${this.formatOutputTitle(key)}`));
+            }
+        }
+        if (state.plan) {
+            console.log('');
+            console.log(chalk.dim(`Task type: ${state.plan.taskType}`));
+            console.log(chalk.dim(`Complexity: ${state.plan.estimatedComplexity}`));
+        }
+        console.log('');
+    }
+}

package/dist/orchestrator/planner.d.ts

@@ -0,0 +1,44 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { AgentConfig } from '../bmad/index.js';
+export interface PlannedStep {
+    agent: string;
+    action: string;
+    description: string;
+    dependsOn: string[];
+    outputKey: string;
+    priority: 'required' | 'recommended' | 'optional';
+}
+export interface ExecutionPlan {
+    task: string;
+    taskType: TaskType;
+    summary: string;
+    steps: PlannedStep[];
+    estimatedComplexity: 'simple' | 'moderate' | 'complex';
+    reasoning: string;
+}
+export type TaskType = 'new_feature' | 'bug_fix' | 'refactor' | 'documentation' | 'testing' | 'code_review' | 'architecture' | 'analysis' | 'general';
+export declare const AGENT_CAPABILITIES: Record<string, {
+    name: string;
+    capabilities: string[];
+    bestFor: string[];
+}>;
+export declare class TaskPlanner {
+    private client;
+    private model;
+    private availableAgents;
+    constructor(client: Anthropic, model: string, availableAgents: Map<string, AgentConfig>);
+    createPlan(task: string, context: {
+        stack?: {
+            language: string;
+            framework?: string;
+        };
+        hasProjectDocs: boolean;
+        existingCode: boolean;
+    }): Promise<ExecutionPlan>;
+    private buildAgentDescriptions;
+    private createDefaultPlan;
+    validatePlan(plan: ExecutionPlan): {
+        valid: boolean;
+        errors: string[];
+    };
+}