aided-dev 1.0.0

package/dist/orchestrator/planner.js

@@ -0,0 +1,355 @@
+export const AGENT_CAPABILITIES = {
+    analyst: {
+        name: 'Mary (Analyst)',
+        capabilities: [
+            'Requirements gathering and analysis',
+            'Creating Product Requirements Documents (PRD)',
+            'Market research and competitive analysis',
+            'User story creation',
+            'Business analysis',
+            'Stakeholder requirements elicitation',
+        ],
+        bestFor: ['new_feature', 'analysis', 'architecture'],
+    },
+    architect: {
+        name: 'Winston (Architect)',
+        capabilities: [
+            'System architecture design',
+            'Technical design documents',
+            'API design and specifications',
+            'Database schema design',
+            'Technology stack selection',
+            'Design patterns and best practices',
+            'Code structure planning',
+        ],
+        bestFor: ['new_feature', 'architecture', 'refactor'],
+    },
+    dev: {
+        name: 'Amelia (Developer)',
+        capabilities: [
+            'Code implementation',
+            'Bug fixing',
+            'Code refactoring',
+            'Feature development',
+            'API implementation',
+            'Integration development',
+            'Performance optimization',
+        ],
+        bestFor: ['new_feature', 'bug_fix', 'refactor', 'general'],
+    },
+    tea: {
+        name: 'Murat (Test Architect)',
+        capabilities: [
+            'Test strategy design',
+            'Unit test creation',
+            'Integration test creation',
+            'E2E test creation',
+            'Test coverage analysis',
+            'Quality assurance',
+        ],
+        bestFor: ['testing', 'new_feature', 'bug_fix'],
+    },
+    pm: {
+        name: 'PM (Product Manager)',
+        capabilities: [
+            'Product roadmap planning',
+            'Feature prioritization',
+            'Sprint planning',
+            'Release management',
+            'Stakeholder communication',
+        ],
+        bestFor: ['new_feature', 'analysis'],
+    },
+    'tech-writer': {
+        name: 'Tech Writer',
+        capabilities: [
+            'API documentation',
+            'User guides',
+            'Technical specifications',
+            'README files',
+            'Code comments and JSDoc',
+        ],
+        bestFor: ['documentation'],
+    },
+    'ux-designer': {
+        name: 'UX Designer',
+        capabilities: [
+            'User interface design',
+            'User experience flows',
+            'Wireframes and mockups',
+            'Usability analysis',
+        ],
+        bestFor: ['new_feature', 'analysis'],
+    },
+    sm: {
+        name: 'SM (Scrum Master)',
+        capabilities: [
+            'Process facilitation',
+            'Workflow optimization',
+            'Team coordination',
+            'Agile practices',
+        ],
+        bestFor: ['analysis', 'general'],
+    },
+};
+export class TaskPlanner {
+    client;
+    model;
+    availableAgents;
+    constructor(client, model, availableAgents) {
+        this.client = client;
+        this.model = model;
+        this.availableAgents = availableAgents;
+    }
+    async createPlan(task, context) {
+        const agentDescriptions = this.buildAgentDescriptions();
+        const plannerPrompt = `You are an AI orchestration planner. Your job is to analyze a development task and create an execution plan that determines which AI agents to use and in what order.
+
+## Available Agents
+
+${agentDescriptions}
+
+## Task Analysis Guidelines
+
+1. **Identify Task Type**: Determine what kind of task this is:
+   - new_feature: Building something new
+   - bug_fix: Fixing an issue
+   - refactor: Improving existing code
+   - documentation: Writing docs
+   - testing: Creating tests
+   - code_review: Reviewing code
+   - architecture: Designing systems
+   - analysis: Research/investigation
+   - general: Other tasks
+
+2. **Select Agents**: Choose agents based on the task:
+   - Simple bug fixes may only need: dev
+   - New features typically need: analyst → architect → dev → tea
+   - Documentation tasks need: tech-writer (or dev if code-focused)
+   - Testing tasks need: tea
+   - Refactoring needs: architect → dev
+   - Not every task needs all agents!
+
+3. **Determine Order**: Agents should be called in logical order based on dependencies.
+
+4. **Set Priorities**:
+   - required: Must complete for task success
+   - recommended: Improves quality but not essential
+   - optional: Nice to have
+
+## Context
+
+${context.stack ? `Project Stack: ${context.stack.language}${context.stack.framework ? ` / ${context.stack.framework}` : ''}` : 'Stack: Unknown'}
+Has Project Documentation: ${context.hasProjectDocs ? 'Yes' : 'No'}
+Existing Codebase: ${context.existingCode ? 'Yes (brownfield)' : 'No (greenfield)'}
+
+## Output Format
+
+Respond with a JSON object (and nothing else) in this exact format:
+{
+  "taskType": "new_feature|bug_fix|refactor|documentation|testing|code_review|architecture|analysis|general",
+  "summary": "One sentence summary of what needs to be done",
+  "estimatedComplexity": "simple|moderate|complex",
+  "reasoning": "Brief explanation of why these agents were selected",
+  "steps": [
+    {
+      "agent": "agent_key",
+      "action": "Brief action description",
+      "description": "What this agent will do",
+      "dependsOn": ["previous_step_outputKey"],
+      "outputKey": "unique_key_for_this_step",
+      "priority": "required|recommended|optional"
+    }
+  ]
+}`;
+        const response = await this.client.messages.create({
+            model: this.model,
+            max_tokens: 2048,
+            system: plannerPrompt,
+            messages: [
+                {
+                    role: 'user',
+                    content: `Create an execution plan for this task:\n\n${task}`,
+                },
+            ],
+        });
+        const responseText = response.content
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text)
+            .join('\n');
+        try {
+            const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                throw new Error('No JSON found in response');
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            const validSteps = parsed.steps.filter((step) => this.availableAgents.has(step.agent) || AGENT_CAPABILITIES[step.agent]);
+            return {
+                task,
+                taskType: parsed.taskType || 'general',
+                summary: parsed.summary || task,
+                steps: validSteps,
+                estimatedComplexity: parsed.estimatedComplexity || 'moderate',
+                reasoning: parsed.reasoning || '',
+            };
+        }
+        catch (error) {
+            return this.createDefaultPlan(task, context);
+        }
+    }
+    buildAgentDescriptions() {
+        const descriptions = [];
+        for (const [key, info] of Object.entries(AGENT_CAPABILITIES)) {
+            const isAvailable = this.availableAgents.has(key);
+            const status = isAvailable ? '✓' : '○';
+            descriptions.push(`### ${status} ${info.name} (key: "${key}")
+Capabilities: ${info.capabilities.join(', ')}
+Best for: ${info.bestFor.join(', ')}`);
+        }
+        return descriptions.join('\n\n');
+    }
+    createDefaultPlan(task, context) {
+        const taskLower = task.toLowerCase();
+        let taskType = 'general';
+        let steps = [];
+        if (taskLower.includes('fix') || taskLower.includes('bug') || taskLower.includes('issue')) {
+            taskType = 'bug_fix';
+            steps = [
+                {
+                    agent: 'dev',
+                    action: 'Fix bug',
+                    description: 'Analyze and fix the reported issue',
+                    dependsOn: [],
+                    outputKey: 'fix',
+                    priority: 'required',
+                },
+                {
+                    agent: 'tea',
+                    action: 'Add tests',
+                    description: 'Add tests to prevent regression',
+                    dependsOn: ['fix'],
+                    outputKey: 'tests',
+                    priority: 'recommended',
+                },
+            ];
+        }
+        else if (taskLower.includes('test')) {
+            taskType = 'testing';
+            steps = [
+                {
+                    agent: 'tea',
+                    action: 'Create tests',
+                    description: 'Design and implement test suite',
+                    dependsOn: [],
+                    outputKey: 'tests',
+                    priority: 'required',
+                },
+            ];
+        }
+        else if (taskLower.includes('document') || taskLower.includes('readme') || taskLower.includes('docs')) {
+            taskType = 'documentation';
+            steps = [
+                {
+                    agent: 'dev',
+                    action: 'Create documentation',
+                    description: 'Write technical documentation',
+                    dependsOn: [],
+                    outputKey: 'docs',
+                    priority: 'required',
+                },
+            ];
+        }
+        else if (taskLower.includes('refactor') || taskLower.includes('clean') || taskLower.includes('improve')) {
+            taskType = 'refactor';
+            steps = [
+                {
+                    agent: 'architect',
+                    action: 'Design refactor',
+                    description: 'Plan the refactoring approach',
+                    dependsOn: [],
+                    outputKey: 'design',
+                    priority: 'required',
+                },
+                {
+                    agent: 'dev',
+                    action: 'Implement refactor',
+                    description: 'Execute the refactoring',
+                    dependsOn: ['design'],
+                    outputKey: 'implementation',
+                    priority: 'required',
+                },
+            ];
+        }
+        else {
+            taskType = 'new_feature';
+            steps = [
+                {
+                    agent: 'analyst',
+                    action: 'Create PRD',
+                    description: 'Analyze requirements and create PRD',
+                    dependsOn: [],
+                    outputKey: 'prd',
+                    priority: 'required',
+                },
+                {
+                    agent: 'architect',
+                    action: 'Design architecture',
+                    description: 'Design technical architecture',
+                    dependsOn: ['prd'],
+                    outputKey: 'architecture',
+                    priority: 'required',
+                },
+                {
+                    agent: 'dev',
+                    action: 'Implement',
+                    description: 'Write the code',
+                    dependsOn: ['architecture'],
+                    outputKey: 'implementation',
+                    priority: 'required',
+                },
+                {
+                    agent: 'tea',
+                    action: 'Create tests',
+                    description: 'Generate test suite',
+                    dependsOn: ['implementation'],
+                    outputKey: 'tests',
+                    priority: 'recommended',
+                },
+            ];
+        }
+        return {
+            task,
+            taskType,
+            summary: task,
+            steps,
+            estimatedComplexity: 'moderate',
+            reasoning: 'Default plan based on task keywords',
+        };
+    }
+    validatePlan(plan) {
+        const errors = [];
+        const outputKeys = new Set();
+        for (const step of plan.steps) {
+            if (!this.availableAgents.has(step.agent) && !AGENT_CAPABILITIES[step.agent]) {
+                errors.push(`Agent '${step.agent}' is not available`);
+            }
+            for (const dep of step.dependsOn) {
+                if (!outputKeys.has(dep)) {
+                    const depIndex = plan.steps.findIndex((s) => s.outputKey === dep);
+                    const currentIndex = plan.steps.indexOf(step);
+                    if (depIndex === -1) {
+                        errors.push(`Step '${step.outputKey}' depends on '${dep}' which doesn't exist`);
+                    }
+                    else if (depIndex >= currentIndex) {
+                        errors.push(`Step '${step.outputKey}' depends on '${dep}' which comes later`);
+                    }
+                }
+            }
+            outputKeys.add(step.outputKey);
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}

package/dist/postinstall.d.ts

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

package/dist/postinstall.js

@@ -0,0 +1,49 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { setApiKey, hasApiKey, getConfigPath } from './config.js';
+async function main() {
+    if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) {
+        return;
+    }
+    if (hasApiKey()) {
+        return;
+    }
+    console.log('');
+    p.intro(chalk.bgCyan.black(' aidev - AI Development Team Orchestrator '));
+    console.log('');
+    console.log(chalk.dim('Welcome to aidev! To get started, you need an Anthropic API key.'));
+    console.log(chalk.dim('Get one at: https://console.anthropic.com/settings/keys'));
+    console.log('');
+    const apiKey = await p.text({
+        message: 'Enter your Anthropic API key:',
+        placeholder: 'sk-ant-...',
+        validate: (value) => {
+            if (!value) {
+                return 'API key is required. You can also set ANTHROPIC_API_KEY environment variable.';
+            }
+            if (!value.startsWith('sk-ant-')) {
+                return 'Invalid API key format. Should start with sk-ant-';
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(apiKey)) {
+        console.log('');
+        console.log(chalk.yellow('Setup cancelled. You can set the API key later:'));
+        console.log(chalk.dim('  - Set ANTHROPIC_API_KEY environment variable, or'));
+        console.log(chalk.dim('  - Run: aidev config --api-key <your-key>'));
+        console.log('');
+        return;
+    }
+    setApiKey(apiKey);
+    console.log('');
+    console.log(chalk.green('API key saved successfully!'));
+    console.log(chalk.dim(`Config location: ${getConfigPath()}`));
+    console.log('');
+    p.outro(chalk.green('You\'re all set! Run `aidev --help` to get started.'));
+}
+main().catch((error) => {
+    if (process.env.DEBUG) {
+        console.error('Postinstall error:', error);
+    }
+});

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "aided-dev",
+  "version": "1.0.0",
+  "description": "AI Development Team Orchestrator - BMAD-METHOD integration for automated code generation",
+  "keywords": [
+    "ai",
+    "development",
+    "orchestrator",
+    "bmad",
+    "claude",
+    "anthropic",
+    "code-generation",
+    "agents"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shikharsworks/aided.git"
+  },
+  "homepage": "https://github.com/shikharsworks/aided#readme",
+  "bugs": {
+    "url": "https://github.com/shikharsworks/aided/issues"
+  },
+  "license": "MIT",
+  "author": "Shikhar Tiwari",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "aidev": "bin/aidev.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node bin/aidev.js",
+    "postinstall": "node dist/postinstall.js 2>/dev/null || true",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@clack/prompts": "^0.11.0",
+    "bmad-method": "^4.44.3",
+    "chalk": "^5.3.0",
+    "commander": "^14.0.0",
+    "conf": "^13.0.0",
+    "fs-extra": "^11.3.0",
+    "glob": "^11.0.3",
+    "js-yaml": "^4.1.0",
+    "ora": "^8.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}