aided-dev 1.0.5 → 1.0.7

package/dist/cli.js

@@ -15,6 +15,7 @@ program
     .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())
+    .option('-a, --apply', 'Apply code changes directly to the repository')
     .action(async (prompt, options) => {
     if (!prompt) {
         program.help();
@@ -48,6 +49,7 @@ program
             repoPath: options.dir,
             model: options.model,
             verbose: options.verbose,
+            applyChanges: options.apply,
         });
         await orchestrator.run(prompt);
     }
@@ -256,10 +258,18 @@ program
     console.log('  aided "Document all REST API endpoints"');
     console.log('');
     console.log(chalk.cyan('Options:'));
+    console.log('  -a, --apply            Apply code changes directly to repo');
     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('Examples with --apply:'));
+    console.log(chalk.dim('  # Create new feature and write files'));
+    console.log('  aided "Add user dashboard" --apply');
+    console.log('');
+    console.log(chalk.dim('  # Fix a bug in existing code'));
+    console.log('  aided "Fix: null check in auth middleware" --apply');
+    console.log('');
     console.log(chalk.cyan('Other Commands:'));
     console.log('  aided analyze          Analyze project context');
     console.log('  aided agents           List available AI agents');

package/dist/orchestrator/orchestrator.d.ts

@@ -6,6 +6,7 @@ export interface OrchestratorOptions {
     verbose?: boolean;
     skipPlanning?: boolean;
     outputDir?: string;
+    applyChanges?: boolean;
 }
 export interface WorkflowState {
     task: string;
@@ -24,6 +25,7 @@ export declare class Orchestrator {
     private verbose;
     private skipPlanning;
     private outputDir;
+    private applyChanges;
     private bmadLoader;
     private agents;
     private planner;
@@ -42,5 +44,6 @@ export declare class Orchestrator {
     private buildStepPrompt;
     private extractTextContent;
     private saveOutputs;
+    private applyCodeToRepo;
     private printSummary;
 }

package/dist/orchestrator/orchestrator.js

@@ -14,6 +14,7 @@ export class Orchestrator {
     verbose;
     skipPlanning;
     outputDir;
+    applyChanges;
     bmadLoader;
     agents = new Map();
     planner = null;
@@ -28,6 +29,7 @@ export class Orchestrator {
         this.verbose = options.verbose || false;
         this.skipPlanning = options.skipPlanning || false;
         this.outputDir = options.outputDir || path.join(options.repoPath, '.aided-output');
+        this.applyChanges = options.applyChanges || false;
         this.bmadLoader = getLoader();
     }
     async loadAgents() {
@@ -255,7 +257,7 @@ export class Orchestrator {
         return files;
     }
     async scanDirectory(dirPath, files, relativePath, maxDepth) {
-        if (maxDepth <= 0 || files.size > 50)
+        if (maxDepth <= 0 || files.size > 20)
             return;
         const sourceExtensions = ['.ts', '.js', '.py', '.go', '.rs', '.java', '.rb', '.php'];
         try {
@@ -274,11 +276,11 @@ export class Orchestrator {
                     if (sourceExtensions.includes(ext)) {
                         try {
                             const content = fs.readFileSync(fullPath, 'utf-8');
-                            if (content.length < 8000) {
+                            if (content.length < 4000) {
                                 files.set(relPath, content);
                             }
                             else {
-                                files.set(relPath, content.substring(0, 8000) + '\n\n... (truncated)');
+                                files.set(relPath, content.substring(0, 4000) + '\n\n... (truncated)');
                             }
                         }
                         catch {
@@ -361,10 +363,37 @@ 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
+- Follow framework conventions and existing patterns
 
-Output each file with its path and complete code.`,
+## CRITICAL: Output Format
+You MUST output changes in this EXACT format for each file:
+
+For NEW files:
+\`\`\`
+===FILE: path/to/newfile.js
+===ACTION: CREATE
+\`\`\`javascript
+// complete file content here
+\`\`\`
+===END_FILE
+\`\`\`
+
+For MODIFYING existing files:
+\`\`\`
+===FILE: path/to/existing.js
+===ACTION: MODIFY
+===FIND:
+\`\`\`javascript
+// exact code to find and replace
+\`\`\`
+===REPLACE:
+\`\`\`javascript
+// new code to replace with
+\`\`\`
+===END_FILE
+\`\`\`
+
+Stay focused ONLY on the task. Do not add unnecessary features or refactor unrelated code.`,
             tests: `## Task
 ${task}
 
@@ -375,18 +404,45 @@ Generate comprehensive tests for the implementation:
 - Edge cases and error scenarios
 - Use appropriate test framework for the stack
 
-Output test files with paths and complete test code.`,
+## CRITICAL: Output Format
+Output test files using this EXACT format:
+
+\`\`\`
+===FILE: path/to/test.spec.js
+===ACTION: CREATE
+\`\`\`javascript
+// test file content
+\`\`\`
+===END_FILE
+\`\`\``,
             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
+2. Implement the MINIMAL fix required
+3. Do NOT refactor unrelated code
+4. Stay focused on the specific bug
+
+## CRITICAL: Output Format
+Output fixes using this EXACT format:
+
+\`\`\`
+===FILE: path/to/file.js
+===ACTION: MODIFY
+===FIND:
+\`\`\`javascript
+// exact buggy code
+\`\`\`
+===REPLACE:
+\`\`\`javascript
+// fixed code
+\`\`\`
+===END_FILE
+\`\`\`
 
-Output the fixed code with explanations.`,
+ONLY output changes needed for the fix. Do not touch unrelated code.`,
             design: `## Task
 ${task}
 
@@ -480,6 +536,119 @@ ${content}
         }
         return runDir;
     }
+    async applyCodeToRepo(state) {
+        const result = { created: [], modified: [], errors: [] };
+        for (const [key, content] of state.outputs) {
+            if (!key.includes('implementation') && !key.includes('code') && !key.includes('fix') && !key.includes('test')) {
+                continue;
+            }
+            const fileBlocks = content.split('===FILE:').slice(1);
+            for (const block of fileBlocks) {
+                try {
+                    const endIndex = block.indexOf('===END_FILE');
+                    const fileBlock = endIndex > -1 ? block.substring(0, endIndex) : block;
+                    const filePathMatch = fileBlock.match(/^([^\n]+)/);
+                    if (!filePathMatch)
+                        continue;
+                    const filePath = filePathMatch[1].trim();
+                    if (filePath.includes('...') || filePath.includes('example') || !filePath.includes('.')) {
+                        continue;
+                    }
+                    const normalizedPath = filePath.replace(/^\/+/, '').replace(/^\.\//, '');
+                    const fullPath = path.join(this.repoPath, normalizedPath);
+                    const actionMatch = fileBlock.match(/===ACTION:\s*(\w+)/);
+                    const action = actionMatch ? actionMatch[1].toUpperCase() : 'CREATE';
+                    if (action === 'CREATE') {
+                        const codeMatch = fileBlock.match(/```(?:\w+)?\n([\s\S]*?)```/);
+                        if (!codeMatch)
+                            continue;
+                        const code = codeMatch[1];
+                        const dirPath = path.dirname(fullPath);
+                        if (!fs.existsSync(dirPath)) {
+                            fs.mkdirSync(dirPath, { recursive: true });
+                        }
+                        fs.writeFileSync(fullPath, code.trim() + '\n');
+                        result.created.push(normalizedPath);
+                    }
+                    else if (action === 'MODIFY') {
+                        const findMatch = fileBlock.match(/===FIND:\s*```(?:\w+)?\n([\s\S]*?)```/);
+                        const replaceMatch = fileBlock.match(/===REPLACE:\s*```(?:\w+)?\n([\s\S]*?)```/);
+                        if (!findMatch || !replaceMatch) {
+                            result.errors.push(`${normalizedPath}: Missing FIND or REPLACE block`);
+                            continue;
+                        }
+                        const findCode = findMatch[1].trim();
+                        const replaceCode = replaceMatch[1].trim();
+                        if (!fs.existsSync(fullPath)) {
+                            result.errors.push(`${normalizedPath}: File not found`);
+                            continue;
+                        }
+                        let fileContent = fs.readFileSync(fullPath, 'utf-8');
+                        if (fileContent.includes(findCode)) {
+                            fileContent = fileContent.replace(findCode, replaceCode);
+                            fs.writeFileSync(fullPath, fileContent);
+                            result.modified.push(normalizedPath);
+                        }
+                        else {
+                            const normalizedFind = findCode.replace(/\s+/g, ' ').trim();
+                            const normalizedContent = fileContent.replace(/\s+/g, ' ');
+                            if (normalizedContent.includes(normalizedFind)) {
+                                const lines = fileContent.split('\n');
+                                const findLines = findCode.split('\n');
+                                let startLine = -1;
+                                for (let i = 0; i <= lines.length - findLines.length; i++) {
+                                    const segment = lines.slice(i, i + findLines.length).join('\n');
+                                    if (segment.replace(/\s+/g, ' ').trim() === normalizedFind) {
+                                        startLine = i;
+                                        break;
+                                    }
+                                }
+                                if (startLine >= 0) {
+                                    lines.splice(startLine, findLines.length, ...replaceCode.split('\n'));
+                                    fs.writeFileSync(fullPath, lines.join('\n'));
+                                    result.modified.push(normalizedPath);
+                                }
+                                else {
+                                    result.errors.push(`${normalizedPath}: Could not locate code to replace`);
+                                }
+                            }
+                            else {
+                                result.errors.push(`${normalizedPath}: Code to replace not found`);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    result.errors.push(`Error processing block: ${error}`);
+                }
+            }
+            if (result.created.length === 0 && result.modified.length === 0) {
+                const legacyPattern = /###\s+([^\n]+\.[a-zA-Z]+)\s*\n```(?:\w+)?\n([\s\S]*?)```/g;
+                let match;
+                while ((match = legacyPattern.exec(content)) !== null) {
+                    const filePath = match[1].trim();
+                    const code = match[2];
+                    if (filePath.includes('...') || filePath.includes('example') || filePath.startsWith('//')) {
+                        continue;
+                    }
+                    const normalizedPath = filePath.replace(/^\/+/, '').replace(/^\.\//, '');
+                    const fullPath = path.join(this.repoPath, normalizedPath);
+                    const dirPath = path.dirname(fullPath);
+                    try {
+                        if (!fs.existsSync(dirPath)) {
+                            fs.mkdirSync(dirPath, { recursive: true });
+                        }
+                        fs.writeFileSync(fullPath, code.trim() + '\n');
+                        result.created.push(normalizedPath);
+                    }
+                    catch (error) {
+                        result.errors.push(`${normalizedPath}: ${error}`);
+                    }
+                }
+            }
+        }
+        return result;
+    }
     async printSummary(state) {
         console.log('');
         if (state.errors.length > 0) {
@@ -491,6 +660,32 @@ ${content}
         else {
             console.log(chalk.green('✓ Workflow complete!'));
         }
+        if (this.applyChanges && state.outputs.size > 0) {
+            console.log('');
+            console.log(chalk.cyan('Applying code changes to repository...'));
+            const result = await this.applyCodeToRepo(state);
+            if (result.created.length > 0) {
+                console.log(chalk.green(`✓ Created ${result.created.length} files:`));
+                for (const file of result.created) {
+                    console.log(chalk.green(`  + ${file}`));
+                }
+            }
+            if (result.modified.length > 0) {
+                console.log(chalk.blue(`✓ Modified ${result.modified.length} files:`));
+                for (const file of result.modified) {
+                    console.log(chalk.blue(`  ~ ${file}`));
+                }
+            }
+            if (result.errors.length > 0) {
+                console.log(chalk.yellow(`⚠ ${result.errors.length} issues:`));
+                for (const error of result.errors) {
+                    console.log(chalk.yellow(`  ! ${error}`));
+                }
+            }
+            if (result.created.length === 0 && result.modified.length === 0) {
+                console.log(chalk.yellow('  No code changes to apply'));
+            }
+        }
         if (state.outputs.size > 0) {
             const outputPath = await this.saveOutputs(state);
             console.log('');

package/package.json

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