aided-dev 1.0.3 → 1.0.5

package/dist/bmad/loader.d.ts

@@ -59,6 +59,7 @@ export declare class BMADLoader {
     getPath(): string | undefined;
     getFormatType(): 'npm' | 'local' | 'unknown';
     listAgents(): Promise<string[]>;
+    listProjectAgents(): Promise<string[]>;
     loadAgent(name: string): Promise<AgentConfig | undefined>;
     loadAgents(names: string[]): Promise<Map<string, AgentConfig>>;
     getLoadedAgents(): Map<string, AgentConfig>;

package/dist/bmad/loader.js

@@ -149,6 +149,11 @@ export class BMADLoader {
                 this.agentsPaths = [localAgentsPath];
             }
         }
+        const projectAgentsDir = path.join(process.cwd(), 'agents');
+        if (fs.existsSync(projectAgentsDir)) {
+            this.agentsPaths.push(projectAgentsDir);
+        }
+        this.agentsPaths.push(process.cwd());
     }
     isAvailable() {
         return !!this.bmadPath && this.agentsPaths.length > 0;
@@ -176,6 +181,31 @@ export class BMADLoader {
         }
         return [...new Set(agents)];
     }
+    async listProjectAgents() {
+        const agents = [];
+        const cwd = process.cwd();
+        const agentsDir = path.join(cwd, 'agents');
+        if (fs.existsSync(agentsDir)) {
+            const files = await fs.readdir(agentsDir);
+            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', ''));
+                }
+            }
+        }
+        if (fs.existsSync(cwd)) {
+            const files = await fs.readdir(cwd);
+            for (const file of files) {
+                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);

package/dist/cli.js

@@ -161,6 +161,21 @@ program
     if (allAgents.length > agentNames.length) {
         console.log(chalk.dim(`Other available agents: ${allAgents.filter(a => !agentNames.includes(a)).join(', ')}`));
     }
+    const projectAgents = await loader.listProjectAgents();
+    if (projectAgents.length > 0) {
+        console.log('');
+        console.log(chalk.bold('Custom Project Agents'));
+        console.log(chalk.dim(`Location: ${process.cwd()}`));
+        console.log('');
+        for (const agentName of projectAgents) {
+            const agent = await loader.loadAgent(agentName);
+            if (agent) {
+                console.log(`${agent.icon} ${chalk.green(agent.name)} - ${agent.title}`);
+                console.log(chalk.dim(`   Role: ${agent.persona.role}`));
+                console.log('');
+            }
+        }
+    }
 });
 program
     .command('create-agent')

package/dist/orchestrator/orchestrator.d.ts

@@ -12,6 +12,7 @@ export interface WorkflowState {
     repoPath: string;
     projectDocuments?: ProjectDocuments;
     stack?: ProjectStack;
+    repoFiles?: Map<string, string>;
     plan?: ExecutionPlan;
     outputs: Map<string, string>;
     errors: string[];
@@ -34,6 +35,8 @@ export declare class Orchestrator {
     private phasePlanning;
     private executeplan;
     private executeStep;
+    private scanRepository;
+    private scanDirectory;
     private buildContext;
     private formatOutputTitle;
     private buildStepPrompt;

package/dist/orchestrator/orchestrator.js

@@ -92,11 +92,16 @@ export class Orchestrator {
             state.stack = await detectStack(this.repoPath);
             spinner.text = `Detected: ${state.stack.language}`;
             state.projectDocuments = await discoverProjectDocuments(this.repoPath);
+            spinner.text = 'Scanning repository files...';
+            state.repoFiles = await this.scanRepository();
             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.repoFiles && state.repoFiles.size > 0) {
+                console.log(chalk.dim(`  Scanned ${state.repoFiles.size} source files`));
+            }
             if (state.projectDocuments) {
                 const docCount = [
                     state.projectDocuments.brownfieldArchitecture,
@@ -219,6 +224,72 @@ export class Orchestrator {
             }
         }
     }
+    async scanRepository() {
+        const files = new Map();
+        const keyFiles = [
+            'package.json', 'tsconfig.json', 'pyproject.toml', 'requirements.txt',
+            'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle',
+            '.env.example', 'docker-compose.yml', 'Dockerfile',
+            'README.md', 'CLAUDE.md',
+        ];
+        const keyDirs = ['src', 'app', 'lib', 'routes', 'controllers', 'models', 'services', 'api'];
+        for (const file of keyFiles) {
+            const filePath = path.join(this.repoPath, file);
+            if (fs.existsSync(filePath)) {
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    if (content.length < 10000) {
+                        files.set(file, content);
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        for (const dir of keyDirs) {
+            const dirPath = path.join(this.repoPath, dir);
+            if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+                await this.scanDirectory(dirPath, files, dir, 3);
+            }
+        }
+        return files;
+    }
+    async scanDirectory(dirPath, files, relativePath, maxDepth) {
+        if (maxDepth <= 0 || files.size > 50)
+            return;
+        const sourceExtensions = ['.ts', '.js', '.py', '.go', '.rs', '.java', '.rb', '.php'];
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '__pycache__') {
+                    continue;
+                }
+                const fullPath = path.join(dirPath, entry.name);
+                const relPath = path.join(relativePath, entry.name);
+                if (entry.isDirectory()) {
+                    await this.scanDirectory(fullPath, files, relPath, maxDepth - 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name);
+                    if (sourceExtensions.includes(ext)) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8');
+                            if (content.length < 8000) {
+                                files.set(relPath, content);
+                            }
+                            else {
+                                files.set(relPath, content.substring(0, 8000) + '\n\n... (truncated)');
+                            }
+                        }
+                        catch {
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
     buildContext(state, step) {
         const parts = [];
         if (state.stack) {
@@ -228,6 +299,16 @@ export class Orchestrator {
         if (state.projectDocuments) {
             parts.push('\n' + formatDocumentsForPrompt(state.projectDocuments));
         }
+        if (state.repoFiles && state.repoFiles.size > 0) {
+            parts.push('\n## Repository Files');
+            parts.push(`Found ${state.repoFiles.size} key files in the repository:\n`);
+            for (const [filePath, content] of state.repoFiles) {
+                parts.push(`### ${filePath}`);
+                parts.push('```');
+                parts.push(content);
+                parts.push('```\n');
+            }
+        }
         for (const dep of step.dependsOn) {
             const depOutput = state.outputs.get(dep);
             if (depOutput) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aided-dev",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI Development Team Orchestrator - BMAD-METHOD integration for automated code generation",
   "keywords": [
     "ai",