aided-dev 1.0.0

package/dist/cli.js

@@ -0,0 +1,257 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+import { Orchestrator } from './orchestrator/index.js';
+import { setApiKey, hasApiKey, getConfigPath, clearConfig, } from './config.js';
+import { discoverProjectDocuments, detectStack, formatStack, } from './discovery/index.js';
+import { AgentCreator, quickCreateAgent } from './agent-creator/index.js';
+const program = new Command();
+program
+    .name('aidev')
+    .description('AI Development Team Orchestrator - BMAD-METHOD integration')
+    .version('1.0.0');
+program
+    .argument('[prompt]', 'Development task to execute')
+    .option('-m, --model <model>', 'Claude model to use', 'claude-sonnet-4-20250514')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('-d, --dir <path>', 'Project directory', process.cwd())
+    .action(async (prompt, options) => {
+    if (!prompt) {
+        program.help();
+        return;
+    }
+    if (!hasApiKey()) {
+        console.log('');
+        console.log(chalk.yellow('No API key configured.'));
+        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';
+                if (!value.startsWith('sk-ant-'))
+                    return 'Invalid API key format';
+                return undefined;
+            },
+        });
+        if (p.isCancel(apiKey)) {
+            console.log(chalk.red('Cancelled'));
+            process.exit(1);
+        }
+        setApiKey(apiKey);
+        console.log(chalk.green('API key saved!'));
+        console.log('');
+    }
+    try {
+        const orchestrator = new Orchestrator({
+            repoPath: options.dir,
+            model: options.model,
+            verbose: options.verbose,
+        });
+        await orchestrator.run(prompt);
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('config')
+    .description('Configure aidev settings')
+    .option('--api-key <key>', 'Set Anthropic API key')
+    .option('--show', 'Show current configuration')
+    .option('--clear', 'Clear all configuration')
+    .action(async (options) => {
+    if (options.apiKey) {
+        setApiKey(options.apiKey);
+        console.log(chalk.green('API key saved!'));
+        return;
+    }
+    if (options.clear) {
+        clearConfig();
+        console.log(chalk.green('Configuration cleared.'));
+        return;
+    }
+    if (options.show) {
+        console.log('');
+        console.log(chalk.bold('Configuration:'));
+        console.log(`  Path: ${getConfigPath()}`);
+        console.log(`  API Key: ${hasApiKey() ? chalk.green('configured') : chalk.yellow('not set')}`);
+        console.log('');
+        return;
+    }
+    console.log('');
+    p.intro(chalk.bgCyan.black(' aidev Configuration '));
+    const apiKey = await p.text({
+        message: 'Anthropic API key:',
+        placeholder: hasApiKey() ? '(already configured)' : 'sk-ant-...',
+        validate: (value) => {
+            if (!value && !hasApiKey())
+                return 'API key is required';
+            if (value && !value.startsWith('sk-ant-'))
+                return 'Invalid format';
+            return undefined;
+        },
+    });
+    if (!p.isCancel(apiKey) && apiKey) {
+        setApiKey(apiKey);
+        console.log(chalk.green('API key saved!'));
+    }
+    p.outro('Configuration complete!');
+});
+program
+    .command('analyze')
+    .description('Analyze a repository and show detected context')
+    .argument('[path]', 'Repository path', process.cwd())
+    .action(async (repoPath) => {
+    console.log('');
+    console.log(chalk.bold('Analyzing repository:'), repoPath);
+    console.log('');
+    const stack = await detectStack(repoPath);
+    console.log(chalk.cyan('Technology Stack:'));
+    console.log(formatStack(stack).split('\n').map(l => `  ${l}`).join('\n'));
+    console.log('');
+    const docs = await discoverProjectDocuments(repoPath);
+    if (docs) {
+        console.log(chalk.cyan('Source of Truth Documents:'));
+        console.log(`  Project: ${docs.projectName}`);
+        if (docs.brownfieldArchitecture) {
+            console.log(chalk.green(`  ✓ ${docs.projectName}-brownfield-architecture.md`));
+        }
+        if (docs.integrationMap) {
+            console.log(chalk.green(`  ✓ ${docs.projectName}-integration-map.md`));
+        }
+        if (docs.systemAnalysis) {
+            console.log(chalk.green(`  ✓ ${docs.projectName}-system-analysis.md`));
+        }
+    }
+    else {
+        console.log(chalk.yellow('No source-of-truth documents found.'));
+        console.log(chalk.dim('Create these files for better context:'));
+        console.log(chalk.dim('  - <project>-brownfield-architecture.md'));
+        console.log(chalk.dim('  - <project>-integration-map.md'));
+        console.log(chalk.dim('  - <project>-system-analysis.md'));
+    }
+    console.log('');
+});
+program
+    .command('agents')
+    .description('Show information about AI agents (loaded from BMAD-METHOD)')
+    .action(async () => {
+    const { getLoader } = await import('./bmad/index.js');
+    const loader = getLoader();
+    console.log('');
+    console.log(chalk.bold('AI Development Team (BMAD Agents)'));
+    if (loader.isAvailable()) {
+        console.log(chalk.dim(`Loaded from: ${loader.getPath()}`));
+    }
+    else {
+        console.log(chalk.yellow('BMAD-METHOD not found, using fallback agents'));
+    }
+    console.log('');
+    const agentNames = ['analyst', 'architect', 'dev', 'tea'];
+    const agents = await loader.loadAgents(agentNames);
+    for (const [name, agent] of agents) {
+        console.log(`${agent.icon} ${chalk.cyan(agent.name)} - ${agent.title}`);
+        console.log(chalk.dim(`   Role: ${agent.persona.role}`));
+        console.log('');
+    }
+    const allAgents = await loader.listAgents();
+    if (allAgents.length > agentNames.length) {
+        console.log(chalk.dim(`Other available agents: ${allAgents.filter(a => !agentNames.includes(a)).join(', ')}`));
+    }
+});
+program
+    .command('create-agent')
+    .description('Create a new BMAD agent using the agent-builder (Bond)')
+    .option('-q, --quick', 'Quick mode - guided prompts without AI conversation')
+    .option('-o, --output <path>', 'Output directory for the agent file', process.cwd())
+    .option('-m, --model <model>', 'Claude model to use', 'claude-sonnet-4-20250514')
+    .option('-v, --verbose', 'Show detailed output')
+    .action(async (options) => {
+    if (!hasApiKey()) {
+        console.log('');
+        console.log(chalk.yellow('No API key configured.'));
+        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';
+                if (!value.startsWith('sk-ant-'))
+                    return 'Invalid API key format';
+                return undefined;
+            },
+        });
+        if (p.isCancel(apiKey)) {
+            console.log(chalk.red('Cancelled'));
+            process.exit(1);
+        }
+        setApiKey(apiKey);
+        console.log(chalk.green('API key saved!'));
+        console.log('');
+    }
+    try {
+        if (options.quick) {
+            await quickCreateAgent({
+                outputDir: options.output,
+            });
+        }
+        else {
+            const creator = new AgentCreator({
+                outputDir: options.output,
+                model: options.model,
+                verbose: options.verbose,
+            });
+            await creator.create();
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('help-examples')
+    .description('Show usage examples')
+    .action(() => {
+    console.log('');
+    console.log(chalk.bold('aidev - AI Development Team Orchestrator'));
+    console.log('');
+    console.log(chalk.cyan('Quick Start:'));
+    console.log('  aidev config --api-key sk-ant-xxx    Set your API key');
+    console.log('  aidev "Add user authentication"      Run a task');
+    console.log('');
+    console.log(chalk.cyan('Common Tasks:'));
+    console.log(chalk.dim('  # New feature'));
+    console.log('  aidev "Add password reset with email verification"');
+    console.log('');
+    console.log(chalk.dim('  # Bug fix'));
+    console.log('  aidev "Fix: login fails after password change"');
+    console.log('');
+    console.log(chalk.dim('  # Refactoring'));
+    console.log('  aidev "Refactor auth module to use dependency injection"');
+    console.log('');
+    console.log(chalk.dim('  # Testing'));
+    console.log('  aidev "Add unit tests for the user service"');
+    console.log('');
+    console.log(chalk.dim('  # Documentation'));
+    console.log('  aidev "Document all REST API endpoints"');
+    console.log('');
+    console.log(chalk.cyan('Options:'));
+    console.log('  -v, --verbose          Show detailed agent output');
+    console.log('  -d, --dir <path>       Run in specific directory');
+    console.log('  -m, --model <model>    Use different Claude model');
+    console.log('');
+    console.log(chalk.cyan('Other Commands:'));
+    console.log('  aidev analyze          Analyze project context');
+    console.log('  aidev agents           List available AI agents');
+    console.log('  aidev create-agent     Create a custom agent');
+    console.log('  aidev config --show    View configuration');
+    console.log('');
+    console.log(chalk.dim('Full documentation: https://github.com/shikharsworks/aided#readme'));
+    console.log('');
+});
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+declare const ConfigSchema: z.ZodObject<{
+    anthropicApiKey: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodDefault<z.ZodEnum<["claude-sonnet-4-20250514", "claude-opus-4-20250514"]>>;
+    autoCommit: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    defaultModel: "claude-sonnet-4-20250514" | "claude-opus-4-20250514";
+    autoCommit: boolean;
+    anthropicApiKey?: string | undefined;
+}, {
+    anthropicApiKey?: string | undefined;
+    defaultModel?: "claude-sonnet-4-20250514" | "claude-opus-4-20250514" | undefined;
+    autoCommit?: boolean | undefined;
+}>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare function getConfig(): Config;
+export declare function setApiKey(apiKey: string): void;
+export declare function getApiKey(): string | undefined;
+export declare function hasApiKey(): boolean;
+export declare function setDefaultModel(model: string): void;
+export declare function clearConfig(): void;
+export declare function getConfigPath(): string;
+export {};

package/dist/config.js

@@ -0,0 +1,48 @@
+import Conf from 'conf';
+import { z } from 'zod';
+const ConfigSchema = z.object({
+    anthropicApiKey: z.string().optional(),
+    defaultModel: z.enum(['claude-sonnet-4-20250514', 'claude-opus-4-20250514']).default('claude-sonnet-4-20250514'),
+    autoCommit: z.boolean().default(true),
+});
+const config = new Conf({
+    projectName: 'aidev',
+    schema: {
+        anthropicApiKey: {
+            type: 'string',
+        },
+        defaultModel: {
+            type: 'string',
+            default: 'claude-sonnet-4-20250514',
+        },
+        autoCommit: {
+            type: 'boolean',
+            default: true,
+        },
+    },
+});
+export function getConfig() {
+    return {
+        anthropicApiKey: config.get('anthropicApiKey'),
+        defaultModel: config.get('defaultModel') || 'claude-sonnet-4-20250514',
+        autoCommit: config.get('autoCommit') ?? true,
+    };
+}
+export function setApiKey(apiKey) {
+    config.set('anthropicApiKey', apiKey);
+}
+export function getApiKey() {
+    return process.env.ANTHROPIC_API_KEY || config.get('anthropicApiKey');
+}
+export function hasApiKey() {
+    return !!getApiKey();
+}
+export function setDefaultModel(model) {
+    config.set('defaultModel', model);
+}
+export function clearConfig() {
+    config.clear();
+}
+export function getConfigPath() {
+    return config.path;
+}

package/dist/discovery/detector.d.ts

@@ -0,0 +1,12 @@
+export interface ProjectStack {
+    language: string;
+    languageVersion?: string;
+    framework?: string;
+    frameworkVersion?: string;
+    packageManager?: string;
+    testFramework?: string;
+    database?: string;
+    dependencies: string[];
+}
+export declare function detectStack(repoPath: string): Promise<ProjectStack>;
+export declare function formatStack(stack: ProjectStack): string;

package/dist/discovery/detector.js

@@ -0,0 +1,272 @@
+import fs from 'fs-extra';
+import path from 'path';
+const LANGUAGE_MARKERS = {
+    python: {
+        files: ['pyproject.toml', 'setup.py', 'requirements.txt', 'Pipfile'],
+        language: 'python',
+    },
+    javascript: {
+        files: ['package.json'],
+        language: 'javascript',
+    },
+    typescript: {
+        files: ['tsconfig.json'],
+        language: 'typescript',
+    },
+    go: {
+        files: ['go.mod', 'go.sum'],
+        language: 'go',
+    },
+    rust: {
+        files: ['Cargo.toml'],
+        language: 'rust',
+    },
+    java: {
+        files: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+        language: 'java',
+    },
+    ruby: {
+        files: ['Gemfile', 'Rakefile'],
+        language: 'ruby',
+    },
+    php: {
+        files: ['composer.json'],
+        language: 'php',
+    },
+    csharp: {
+        files: ['*.csproj', '*.sln'],
+        language: 'csharp',
+    },
+    kotlin: {
+        files: ['build.gradle.kts'],
+        language: 'kotlin',
+    },
+};
+const FRAMEWORK_DETECTION = {
+    python: {
+        fastapi: 'fastapi',
+        flask: 'flask',
+        django: 'django',
+        starlette: 'starlette',
+        tornado: 'tornado',
+        aiohttp: 'aiohttp',
+    },
+    javascript: {
+        express: 'express',
+        next: 'next.js',
+        react: 'react',
+        vue: 'vue',
+        angular: 'angular',
+        nestjs: 'nestjs',
+        koa: 'koa',
+        hapi: 'hapi',
+    },
+    typescript: {
+        express: 'express',
+        next: 'next.js',
+        react: 'react',
+        vue: 'vue',
+        angular: 'angular',
+        nestjs: 'nestjs',
+    },
+    go: {
+        gin: 'gin',
+        echo: 'echo',
+        fiber: 'fiber',
+        chi: 'chi',
+        mux: 'gorilla/mux',
+    },
+    rust: {
+        actix: 'actix-web',
+        axum: 'axum',
+        rocket: 'rocket',
+        warp: 'warp',
+    },
+    java: {
+        spring: 'spring-boot',
+        quarkus: 'quarkus',
+        micronaut: 'micronaut',
+    },
+    ruby: {
+        rails: 'rails',
+        sinatra: 'sinatra',
+        hanami: 'hanami',
+    },
+};
+export async function detectStack(repoPath) {
+    const stack = {
+        language: 'unknown',
+        dependencies: [],
+    };
+    for (const [, config] of Object.entries(LANGUAGE_MARKERS)) {
+        for (const file of config.files) {
+            const filePath = path.join(repoPath, file);
+            if (await fs.pathExists(filePath)) {
+                stack.language = config.language;
+                break;
+            }
+        }
+        if (stack.language !== 'unknown')
+            break;
+    }
+    switch (stack.language) {
+        case 'python':
+            await detectPythonStack(repoPath, stack);
+            break;
+        case 'javascript':
+        case 'typescript':
+            await detectNodeStack(repoPath, stack);
+            break;
+        case 'go':
+            await detectGoStack(repoPath, stack);
+            break;
+        case 'rust':
+            await detectRustStack(repoPath, stack);
+            break;
+    }
+    return stack;
+}
+async function detectPythonStack(repoPath, stack) {
+    const pyprojectPath = path.join(repoPath, 'pyproject.toml');
+    if (await fs.pathExists(pyprojectPath)) {
+        try {
+            const content = await fs.readFile(pyprojectPath, 'utf-8');
+            const versionMatch = content.match(/python\s*=\s*["']([^"']+)["']/);
+            if (versionMatch) {
+                stack.languageVersion = versionMatch[1];
+            }
+            const depsMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+            if (depsMatch) {
+                const deps = depsMatch[1].match(/["']([^"']+)["']/g);
+                if (deps) {
+                    stack.dependencies = deps.map((d) => d.replace(/["']/g, '').split(/[<>=]/)[0]);
+                }
+            }
+            const frameworks = FRAMEWORK_DETECTION.python;
+            for (const [dep, framework] of Object.entries(frameworks)) {
+                if (stack.dependencies.some((d) => d.toLowerCase().includes(dep))) {
+                    stack.framework = framework;
+                    break;
+                }
+            }
+            if (stack.dependencies.includes('pytest')) {
+                stack.testFramework = 'pytest';
+            }
+        }
+        catch {
+        }
+    }
+    stack.packageManager = 'pip';
+}
+async function detectNodeStack(repoPath, stack) {
+    const packageJsonPath = path.join(repoPath, 'package.json');
+    if (await fs.pathExists(packageJsonPath)) {
+        try {
+            const pkg = await fs.readJson(packageJsonPath);
+            const allDeps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            stack.dependencies = Object.keys(allDeps);
+            if (allDeps.typescript || (await fs.pathExists(path.join(repoPath, 'tsconfig.json')))) {
+                stack.language = 'typescript';
+            }
+            const frameworks = FRAMEWORK_DETECTION[stack.language];
+            for (const [dep, framework] of Object.entries(frameworks)) {
+                if (allDeps[dep]) {
+                    stack.framework = framework;
+                    stack.frameworkVersion = allDeps[dep];
+                    break;
+                }
+            }
+            if (allDeps.jest)
+                stack.testFramework = 'jest';
+            else if (allDeps.vitest)
+                stack.testFramework = 'vitest';
+            else if (allDeps.mocha)
+                stack.testFramework = 'mocha';
+            if (await fs.pathExists(path.join(repoPath, 'pnpm-lock.yaml'))) {
+                stack.packageManager = 'pnpm';
+            }
+            else if (await fs.pathExists(path.join(repoPath, 'yarn.lock'))) {
+                stack.packageManager = 'yarn';
+            }
+            else {
+                stack.packageManager = 'npm';
+            }
+        }
+        catch {
+        }
+    }
+}
+async function detectGoStack(repoPath, stack) {
+    const goModPath = path.join(repoPath, 'go.mod');
+    if (await fs.pathExists(goModPath)) {
+        try {
+            const content = await fs.readFile(goModPath, 'utf-8');
+            const versionMatch = content.match(/go\s+(\d+\.\d+)/);
+            if (versionMatch) {
+                stack.languageVersion = versionMatch[1];
+            }
+            const requireMatch = content.match(/require\s*\(([\s\S]*?)\)/);
+            if (requireMatch) {
+                const deps = requireMatch[1].match(/(\S+)\s+v/g);
+                if (deps) {
+                    stack.dependencies = deps.map((d) => d.replace(/\s+v$/, ''));
+                }
+            }
+            const frameworks = FRAMEWORK_DETECTION.go;
+            for (const [dep, framework] of Object.entries(frameworks)) {
+                if (stack.dependencies.some((d) => d.includes(dep))) {
+                    stack.framework = framework;
+                    break;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    stack.packageManager = 'go mod';
+}
+async function detectRustStack(repoPath, stack) {
+    const cargoPath = path.join(repoPath, 'Cargo.toml');
+    if (await fs.pathExists(cargoPath)) {
+        try {
+            const content = await fs.readFile(cargoPath, 'utf-8');
+            const depsMatch = content.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
+            if (depsMatch) {
+                const deps = depsMatch[1].match(/^(\w[\w-]*)\s*=/gm);
+                if (deps) {
+                    stack.dependencies = deps.map((d) => d.replace(/\s*=$/, ''));
+                }
+            }
+            const frameworks = FRAMEWORK_DETECTION.rust;
+            for (const [dep, framework] of Object.entries(frameworks)) {
+                if (stack.dependencies.some((d) => d.includes(dep))) {
+                    stack.framework = framework;
+                    break;
+                }
+            }
+        }
+        catch {
+        }
+    }
+    stack.packageManager = 'cargo';
+}
+export function formatStack(stack) {
+    const parts = [];
+    parts.push(`Language: ${stack.language}`);
+    if (stack.languageVersion) {
+        parts.push(`Version: ${stack.languageVersion}`);
+    }
+    if (stack.framework) {
+        parts.push(`Framework: ${stack.framework}`);
+    }
+    if (stack.packageManager) {
+        parts.push(`Package Manager: ${stack.packageManager}`);
+    }
+    if (stack.testFramework) {
+        parts.push(`Test Framework: ${stack.testFramework}`);
+    }
+    return parts.join('\n');
+}

package/dist/discovery/documents.d.ts

@@ -0,0 +1,25 @@
+export interface ProjectDocuments {
+    projectName: string;
+    brownfieldArchitecture?: {
+        path: string;
+        content: string;
+    };
+    integrationMap?: {
+        path: string;
+        content: string;
+    };
+    systemAnalysis?: {
+        path: string;
+        content: string;
+    };
+}
+export declare const PROJECT_DOC_PATTERNS: {
+    readonly brownfieldArchitecture: "{project}-brownfield-architecture.md";
+    readonly integrationMap: "{project}-integration-map.md";
+    readonly systemAnalysis: "{project}-system-analysis.md";
+};
+export declare function detectProjectName(repoPath: string): Promise<string | undefined>;
+export declare function findProjectNameFromDocs(repoPath: string): Promise<string | undefined>;
+export declare function discoverProjectDocuments(repoPath: string): Promise<ProjectDocuments | undefined>;
+export declare function hasDocuments(docs: ProjectDocuments | undefined): boolean;
+export declare function formatDocumentsForPrompt(docs: ProjectDocuments): string;