@hyperdrive.bot/bmad-workflow 1.0.2

package/dist/services/orchestration/batch-processor.js

@@ -0,0 +1,187 @@
+/**
+ * Batch Processor Service
+ *
+ * Handles parallel execution of tasks with configurable concurrency,
+ * intervals between batches, and partial failure handling.
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger({ namespace: 'batch' })
+ * const processor = new BatchProcessor(5, 1000, logger)
+ * const results = await processor.processBatch(items, async (item) => {
+ *   return await someAsyncOperation(item)
+ * }, (info) => {
+ *   console.log(`Processing batch ${info.currentBatch}/${info.totalBatches}`)
+ * })
+ * ```
+ */
+import { ValidationError } from '../../utils/errors.js';
+/**
+ * BatchProcessor - Handles parallel batch processing with configurable concurrency
+ *
+ * Processes items in batches with configurable concurrency limits and intervals
+ * between batches. Continues processing even if individual items fail, collecting
+ * both successes and failures.
+ *
+ * @example
+ * const processor = new BatchProcessor(5, 1000, logger)
+ * const results = await processor.processBatch(items, async (item) => {
+ *   return await processItem(item)
+ * })
+ */
+export class BatchProcessor {
+    intervalMs;
+    logger;
+    maxConcurrency;
+    /**
+     * Create a new BatchProcessor instance
+     *
+     * @param maxConcurrency - Maximum number of concurrent operations (must be positive)
+     * @param intervalMs - Milliseconds to wait between batches (must be non-negative)
+     * @param logger - Logger instance for structured logging
+     * @throws {ValidationError} If maxConcurrency is not positive or intervalMs is negative
+     */
+    constructor(maxConcurrency, intervalMs, logger) {
+        // Validate parameters
+        if (!Number.isInteger(maxConcurrency) || maxConcurrency <= 0) {
+            const error = new ValidationError('maxConcurrency must be a positive integer');
+            logger.error({ maxConcurrency }, error.message);
+            throw error;
+        }
+        if (typeof intervalMs !== 'number' || intervalMs < 0) {
+            const error = new ValidationError('intervalMs must be a non-negative number');
+            logger.error({ intervalMs }, error.message);
+            throw error;
+        }
+        this.maxConcurrency = maxConcurrency;
+        this.intervalMs = intervalMs;
+        this.logger = logger;
+        this.logger.info({ intervalMs: this.intervalMs, maxConcurrency: this.maxConcurrency }, 'BatchProcessor initialized');
+    }
+    /**
+     * Process items in parallel batches with partial failure handling
+     *
+     * Divides items into batches of size maxConcurrency, processes each batch
+     * with Promise.allSettled, waits intervalMs between batches, and collects
+     * all results including both successes and failures.
+     *
+     * @param items - Array of items to process
+     * @param processor - Async function to process each item
+     * @param onProgress - Optional callback for progress updates
+     * @returns Array of BatchResult objects in original item order
+     *
+     * @example
+     * const results = await processor.processBatch(items, async (item) => {
+     *   return await processItem(item)
+     * }, (info) => {
+     *   console.log(`Batch ${info.currentBatch}/${info.totalBatches}`)
+     * })
+     */
+    async processBatch(items, processor, onProgress) {
+        const results = [];
+        // Handle empty array edge case
+        if (items.length === 0) {
+            this.logger.info('No items to process');
+            return results;
+        }
+        // Divide items into batches
+        const batches = this.splitIntoBatches(items, this.maxConcurrency);
+        const totalBatches = batches.length;
+        this.logger.info({ batchSize: this.maxConcurrency, totalBatches, totalItems: items.length }, 'Starting batch processing');
+        let completedItems = 0;
+        // Process batches sequentially to control concurrency and rate limiting
+        for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+            const batch = batches[batchIndex];
+            const currentBatch = batchIndex + 1;
+            this.logger.debug({ currentBatch, itemsInBatch: batch.length, totalBatches }, 'Processing batch');
+            // Call progress callback at start of batch if provided
+            if (onProgress) {
+                try {
+                    onProgress({
+                        completedItems,
+                        currentBatch,
+                        currentItem: batchIndex * this.maxConcurrency + 1,
+                        totalBatches,
+                        totalItems: items.length,
+                    });
+                }
+                catch (error) {
+                    this.logger.error({ error }, 'Progress callback threw error');
+                }
+            }
+            // Process batch in parallel with Promise.allSettled to handle partial failures
+            const batchPromises = batch.map((item, itemIndex) => {
+                const globalIndex = batchIndex * this.maxConcurrency + itemIndex;
+                return processor(item)
+                    .then((result) => {
+                    this.logger.debug({ index: globalIndex }, 'Item processed successfully');
+                    return { result, success: true };
+                })
+                    .catch((error) => {
+                    const err = error;
+                    this.logger.error({ error: err.message, index: globalIndex, itemIndex }, 'Item processing failed');
+                    return { error: err, success: false };
+                });
+            });
+            // eslint-disable-next-line no-await-in-loop -- batches processed sequentially by design
+            const batchResults = await Promise.all(batchPromises);
+            // Collect results
+            for (const result of batchResults) {
+                results.push(result);
+                if (result.success) {
+                    completedItems++;
+                }
+                // Call progress callback after each item completes
+                if (onProgress) {
+                    try {
+                        onProgress({
+                            completedItems,
+                            currentBatch,
+                            currentItem: results.length,
+                            totalBatches,
+                            totalItems: items.length,
+                        });
+                    }
+                    catch (error) {
+                        this.logger.error({ error }, 'Progress callback threw error');
+                    }
+                }
+            }
+            // Wait between batches (except after last batch) to control rate limiting
+            if (batchIndex < batches.length - 1 && this.intervalMs > 0) {
+                this.logger.debug({ intervalMs: this.intervalMs }, 'Waiting between batches');
+                // eslint-disable-next-line no-await-in-loop -- intentional delay between batches for rate limiting
+                await this.delay(this.intervalMs);
+            }
+        }
+        const successCount = results.filter((r) => r.success).length;
+        const errorCount = results.filter((r) => !r.success).length;
+        this.logger.info({ errorCount, successCount }, 'Batch processing complete');
+        return results;
+    }
+    /**
+     * Delay execution for specified milliseconds
+     *
+     * @param ms - Milliseconds to wait
+     * @returns Promise that resolves after delay
+     */
+    async delay(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+    /**
+     * Split array into batches of specified size
+     *
+     * @param items - Array of items to split
+     * @param batchSize - Maximum items per batch
+     * @returns Array of batches
+     */
+    splitIntoBatches(items, batchSize) {
+        const batches = [];
+        for (let i = 0; i < items.length; i += batchSize) {
+            batches.push(items.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+}

package/dist/services/orchestration/dependency-graph-executor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * DependencyGraphExecutor
+ *
+ * Executes task graphs with dependency-aware parallel execution.
+ * Uses layer-based execution where each layer runs in parallel,
+ * but layers execute sequentially to respect dependencies.
+ */
+import type pino from 'pino';
+import type { GraphExecutionResult, TaskGraph } from '../../types/task-graph.js';
+import type { AIProviderRunner } from '../agents/agent-runner.js';
+import type { FileManager } from '../file-system/file-manager.js';
+import type { BatchProcessor } from './batch-processor.js';
+/**
+ * Progress callback for layer execution
+ */
+export type LayerProgressCallback = (layerIndex: number, totalLayers: number, layerSize: number) => void;
+/**
+ * Progress callback for task execution
+ */
+export type TaskProgressCallback = (taskId: string, layerIndex: number, taskIndex: number, totalTasks: number) => void;
+/**
+ * Executor for dependency graph task execution
+ */
+export declare class DependencyGraphExecutor {
+    private readonly agentRunner;
+    private readonly batchProcessor;
+    private readonly cwd?;
+    private readonly fileManager;
+    private readonly logger;
+    private readonly taskGraph;
+    constructor(taskGraph: TaskGraph, agentRunner: AIProviderRunner, batchProcessor: BatchProcessor, fileManager: FileManager, logger: pino.Logger, cwd?: string);
+    /**
+     * Execute the entire task graph
+     *
+     * @param onLayerStart - Callback when a layer starts
+     * @param onTaskStart - Callback when a task starts
+     * @returns Execution result with success status and task results
+     */
+    execute(onLayerStart?: LayerProgressCallback, onTaskStart?: TaskProgressCallback): Promise<GraphExecutionResult>;
+    /**
+     * Build the full prompt for a task
+     */
+    private buildTaskPrompt;
+    /**
+     * Count how many target files were modified by comparing before/after content
+     */
+    private countModifiedFiles;
+    /**
+     * Execute a single task
+     */
+    private executeTask;
+    /**
+     * Scaffold a story file with pre-populated structure
+     */
+    private scaffoldStoryFile;
+    /**
+     * Check if a layer should be skipped due to failed dependencies
+     */
+    private shouldSkipLayer;
+}

package/dist/services/orchestration/dependency-graph-executor.js

@@ -0,0 +1,447 @@
+/**
+ * DependencyGraphExecutor
+ *
+ * Executes task graphs with dependency-aware parallel execution.
+ * Uses layer-based execution where each layer runs in parallel,
+ * but layers execute sequentially to respect dependencies.
+ */
+/**
+ * Executor for dependency graph task execution
+ */
+export class DependencyGraphExecutor {
+    agentRunner;
+    batchProcessor;
+    cwd;
+    fileManager;
+    logger;
+    taskGraph;
+    // eslint-disable-next-line max-params -- Constructor dependencies will be refactored to config object in future
+    constructor(taskGraph, agentRunner, batchProcessor, fileManager, logger, cwd) {
+        this.taskGraph = taskGraph;
+        this.agentRunner = agentRunner;
+        this.batchProcessor = batchProcessor;
+        this.fileManager = fileManager;
+        this.logger = logger;
+        this.cwd = cwd;
+    }
+    /**
+     * Execute the entire task graph
+     *
+     * @param onLayerStart - Callback when a layer starts
+     * @param onTaskStart - Callback when a task starts
+     * @returns Execution result with success status and task results
+     */
+    async execute(onLayerStart, onTaskStart) {
+        this.logger.info({
+            goal: this.taskGraph.goal,
+            layers: this.taskGraph.metadata.executionLayers.length,
+            totalTasks: this.taskGraph.metadata.totalTasks,
+        }, 'Starting task graph execution');
+        const startTime = Date.now();
+        const taskResults = [];
+        const layerResults = [];
+        const taskMap = new Map(this.taskGraph.tasks.map((t) => [t.id, t]));
+        let completedTasks = 0;
+        let failedTasks = 0;
+        let skippedTasks = 0;
+        // Execute layer by layer - layers must be processed sequentially to respect dependencies
+        for (let layerIndex = 0; layerIndex < this.taskGraph.metadata.executionLayers.length; layerIndex++) {
+            const layer = this.taskGraph.metadata.executionLayers[layerIndex];
+            const layerStartTime = Date.now();
+            this.logger.info({
+                layerIndex,
+                layerSize: layer.length,
+                totalLayers: this.taskGraph.metadata.executionLayers.length,
+            }, `Starting layer ${layerIndex + 1}/${this.taskGraph.metadata.executionLayers.length}`);
+            // Notify layer start
+            if (onLayerStart) {
+                onLayerStart(layerIndex, this.taskGraph.metadata.executionLayers.length, layer.length);
+            }
+            // Check if any dependencies failed (if so, skip this layer)
+            const shouldSkipLayer = this.shouldSkipLayer(layer, taskMap, taskResults);
+            if (shouldSkipLayer) {
+                this.logger.warn({ layerIndex, layerSize: layer.length }, 'Skipping layer due to failed dependencies');
+                // Mark all tasks in this layer as skipped
+                for (const taskId of layer) {
+                    const task = taskMap.get(taskId);
+                    if (!task)
+                        continue;
+                    const skippedResult = {
+                        duration: 0,
+                        errors: 'Skipped due to failed dependencies',
+                        exitCode: -1,
+                        output: '',
+                        success: false,
+                        taskId,
+                    };
+                    taskResults.push(skippedResult);
+                    skippedTasks++;
+                }
+                layerResults.push({
+                    duration: Date.now() - layerStartTime,
+                    layerIndex,
+                    parallelTasksExecuted: 0,
+                    success: false,
+                    taskIds: layer,
+                });
+                continue;
+            }
+            // Execute all tasks in this layer in parallel
+            const layerTasks = layer.map((taskId) => taskMap.get(taskId)).filter((t) => t !== undefined);
+            // eslint-disable-next-line no-await-in-loop -- layers must complete sequentially
+            const results = await this.batchProcessor.processBatch(layerTasks, async (task) => {
+                // Notify task start
+                if (onTaskStart) {
+                    const index = layerTasks.indexOf(task);
+                    onTaskStart(task.id, layerIndex, index, layerTasks.length);
+                }
+                return this.executeTask(task);
+            }, (info) => {
+                this.logger.debug({ current: info.currentItem, layerIndex, total: info.totalItems }, `Layer ${layerIndex + 1} progress: ${info.currentItem}/${info.totalItems} tasks`);
+            });
+            // Process results
+            let layerSuccess = true;
+            for (const result of results) {
+                if (result.success && result.result) {
+                    taskResults.push(result.result);
+                    completedTasks++;
+                }
+                else {
+                    // Task failed
+                    const taskId = layerTasks[results.indexOf(result)]?.id ?? 'unknown';
+                    const failedResult = {
+                        duration: 0,
+                        errors: result.error?.message ?? 'Unknown error',
+                        exitCode: -1,
+                        output: '',
+                        success: false,
+                        taskId,
+                    };
+                    taskResults.push(failedResult);
+                    failedTasks++;
+                    layerSuccess = false;
+                }
+            }
+            layerResults.push({
+                duration: Date.now() - layerStartTime,
+                layerIndex,
+                parallelTasksExecuted: layer.length,
+                success: layerSuccess,
+                taskIds: layer,
+            });
+            this.logger.info({
+                duration: Date.now() - layerStartTime,
+                layerIndex,
+                layerSuccess,
+            }, `Completed layer ${layerIndex + 1}/${this.taskGraph.metadata.executionLayers.length}`);
+        }
+        const totalDuration = Date.now() - startTime;
+        const result = {
+            completedTasks,
+            executionSummary: {
+                layerResults,
+            },
+            failedTasks,
+            skippedTasks,
+            success: failedTasks === 0 && skippedTasks === 0,
+            taskResults,
+            totalDuration,
+            totalTasks: this.taskGraph.metadata.totalTasks,
+        };
+        this.logger.info({
+            completedTasks,
+            failedTasks,
+            skippedTasks,
+            success: result.success,
+            totalDuration,
+        }, 'Task graph execution complete');
+        return result;
+    }
+    /**
+     * Build the full prompt for a task
+     */
+    buildTaskPrompt(task) {
+        let prompt = `${this.taskGraph.masterPrompt}
+
+---
+
+## TASK: ${task.title}
+
+${task.description}
+
+${task.prompt}
+
+## CRITICAL REQUIREMENT: MAKE ACTUAL CODE CHANGES
+
+**YOU MUST MODIFY SOURCE CODE FILES.** Analysis-only completion is NOT acceptable.
+
+Before marking this task complete, you MUST:
+1. Make actual changes to source files (not just the story/output file)
+2. Run verification (lint, tests, type-check) to prove changes work
+3. If issues are "already fixed", find OTHER improvements to make (refactoring, better types, cleanup)
+
+DO NOT:
+- Complete with "no changes needed" or "already correct"
+- Only document findings without making fixes
+- Write analysis without modifying source code
+
+If you cannot find issues to fix, you MUST:
+- Add eslint-disable comments with justifications for intentional warnings
+- Refactor for better readability
+- Improve type safety
+- Add missing documentation
+- Extract helper functions to reduce complexity
+
+**ZERO source file modifications = TASK FAILURE**
+
+`;
+        // Add target files if specified
+        if (task.targetFiles && task.targetFiles.length > 0) {
+            prompt += `\n## TARGET FILES\n`;
+            for (const file of task.targetFiles) {
+                prompt += `@${file}\n`;
+            }
+            prompt += '\n';
+        }
+        // Add output file instruction (conditional based on story format)
+        // eslint-disable-next-line unicorn/prefer-ternary
+        if (this.taskGraph.metadata.storyFormat) {
+            // Reference the scaffolded file
+            prompt += `## OUTPUT - STORY DOCUMENT UPDATE
+
+Target story file: @${task.outputFile}
+
+IMPORTANT: The target file has been pre-scaffolded with story structure and metadata.
+
+Your task is to UPDATE the existing story file by:
+- Changing Status from "Draft" to "Completed"
+- Filling in sections marked with [AI Agent will populate]
+- Checking off completed tasks/subtasks ([ ] → [x])
+- Adding your findings to "## Dev Notes" section
+- Adding completion entry to "## Change Log" table
+
+DO NOT:
+- Modify the story title or ID
+- Change the original "## Story" user story format
+- Change the "## Acceptance Criteria" list
+- Remove any sections or change section headers
+- Write conversational summaries outside the story structure
+
+The file @${task.outputFile} already exists with the proper structure - just populate the empty sections.
+
+`;
+        }
+        else {
+            prompt += `## OUTPUT
+Write your results and any notes to: ${task.outputFile}
+
+Use the file at the path above to document:
+- What you did
+- What worked
+- Any issues encountered
+- Next steps or recommendations
+
+`;
+        }
+        return prompt;
+    }
+    /**
+     * Count how many target files were modified by comparing before/after content
+     */
+    async countModifiedFiles(targetFiles, contentsBefore) {
+        let filesModified = 0;
+        for (const filePath of targetFiles) {
+            try {
+                // eslint-disable-next-line no-await-in-loop -- must check each file sequentially for modification verification
+                const contentAfter = await this.fileManager.readFile(filePath);
+                const contentBefore = contentsBefore.get(filePath) ?? '';
+                if (contentAfter !== contentBefore) {
+                    filesModified++;
+                }
+            }
+            catch {
+                // File read failed, skip
+            }
+        }
+        return filesModified;
+    }
+    /**
+     * Execute a single task
+     */
+    async executeTask(task) {
+        this.logger.info({ estimatedMinutes: task.estimatedMinutes, taskId: task.id, title: task.title }, 'Executing task');
+        const startTime = Date.now();
+        try {
+            // Ensure output directory exists
+            const outputDir = task.outputFile.slice(0, Math.max(0, task.outputFile.lastIndexOf('/')));
+            await this.fileManager.createDirectory(outputDir);
+            // If story format, write scaffolded file FIRST
+            if (this.taskGraph.metadata.storyFormat) {
+                const scaffoldedContent = this.scaffoldStoryFile(task);
+                await this.fileManager.writeFile(task.outputFile, scaffoldedContent);
+                this.logger.debug({ outputFile: task.outputFile, taskId: task.id }, 'Scaffolded story file created');
+            }
+            // Build full prompt with master prompt + task-specific prompt
+            const fullPrompt = this.buildTaskPrompt(task);
+            // Capture target file contents BEFORE execution for verification
+            const targetFileContentsBefore = new Map();
+            if (task.targetFiles && task.targetFiles.length > 0) {
+                for (const filePath of task.targetFiles) {
+                    try {
+                        // eslint-disable-next-line no-await-in-loop -- must capture each file sequentially for before/after comparison
+                        const content = await this.fileManager.readFile(filePath);
+                        targetFileContentsBefore.set(filePath, content);
+                    }
+                    catch {
+                        // File might not exist yet, that's ok
+                        targetFileContentsBefore.set(filePath, '');
+                    }
+                }
+            }
+            // Map agent type to valid values
+            const validAgentTypes = ['analyst', 'architect', 'dev', 'pm', 'prd-fixer', 'quick-flow-solo-dev', 'sm', 'tea', 'tech-writer', 'ux-designer'];
+            const agentType = validAgentTypes.includes(task.agentType)
+                ? task.agentType
+                : 'dev';
+            // Execute agent
+            const result = await this.agentRunner.runAgent(fullPrompt, {
+                agentType,
+                references: task.targetFiles, // Pass target files as references
+                timeout: task.estimatedMinutes * 60 * 1000 * 1.5, // 1.5x estimated time as buffer
+            });
+            // Verify target files were actually modified
+            const filesModified = await this.countModifiedFiles(task.targetFiles ?? [], targetFileContentsBefore);
+            if (task.targetFiles && task.targetFiles.length > 0) {
+                if (filesModified === 0) {
+                    this.logger.warn({
+                        targetFiles: task.targetFiles.length,
+                        taskId: task.id,
+                    }, 'WARNING: Task completed but NO target source files were modified. This may indicate an analysis-only completion.');
+                }
+                else {
+                    this.logger.info({
+                        filesModified,
+                        targetFiles: task.targetFiles.length,
+                        taskId: task.id,
+                    }, 'Target source files were modified');
+                }
+            }
+            // Write output to file (or verify it was updated in story format mode)
+            if (this.taskGraph.metadata.storyFormat) {
+                // In story format, Claude should have updated the file via @ reference
+                // Verify the file was actually modified
+                const updatedContent = await this.fileManager.readFile(task.outputFile);
+                const scaffoldedContent = this.scaffoldStoryFile(task);
+                if (updatedContent === scaffoldedContent) {
+                    this.logger.warn({ taskId: task.id }, 'Story file was not updated by agent');
+                    // Write agent output as fallback
+                    await this.fileManager.writeFile(task.outputFile, result.output);
+                }
+            }
+            else {
+                // Regular mode: write agent output directly
+                await this.fileManager.writeFile(task.outputFile, result.output);
+            }
+            const duration = Date.now() - startTime;
+            this.logger.info({
+                duration,
+                exitCode: result.exitCode,
+                success: result.success,
+                taskId: task.id,
+            }, 'Task execution complete');
+            return {
+                duration,
+                errors: result.errors,
+                exitCode: result.exitCode,
+                output: result.output,
+                success: result.success,
+                taskId: task.id,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const err = error;
+            this.logger.error({
+                duration,
+                error: err.message,
+                taskId: task.id,
+            }, 'Task execution failed');
+            return {
+                duration,
+                errors: err.message,
+                exitCode: -1,
+                output: '',
+                success: false,
+                taskId: task.id,
+            };
+        }
+    }
+    /**
+     * Scaffold a story file with pre-populated structure
+     */
+    scaffoldStoryFile(task) {
+        const currentDate = new Date().toISOString().split('T')[0];
+        return `# Story ${task.id}: ${task.title}
+
+<!-- Powered by BMAD™ Core -->
+
+## Status
+
+Draft
+
+---
+
+## Story
+
+${task.prompt.includes('**As a**') ? task.prompt.match(/## Story\n([\s\S]*?)(?=\n##|$)/)?.[1]?.trim() || '_[AI Agent will populate]_' : '_[AI Agent will populate]_'}
+
+---
+
+## Acceptance Criteria
+
+${task.prompt.includes('## Acceptance Criteria') ? task.prompt.match(/## Acceptance Criteria\n([\s\S]*?)(?=\n##|$)/)?.[1]?.trim() || '_[AI Agent will populate]_' : '_[AI Agent will populate]_'}
+
+---
+
+## Tasks / Subtasks
+
+${task.prompt.includes('## Tasks / Subtasks') ? task.prompt.match(/## Tasks \/ Subtasks\n([\s\S]*?)(?=\n##|$)/)?.[1]?.trim() || '_[AI Agent will populate]_' : '_[AI Agent will populate]_'}
+
+---
+
+## Dev Notes
+
+_[AI Agent will populate: Your findings, what you fixed/changed, issues encountered]_
+
+### Testing
+
+${task.prompt.includes('### Testing') ? task.prompt.match(/### Testing\n([\s\S]*?)(?=\n##|$)/)?.[1]?.trim() || '_[AI Agent will populate]_' : '_[AI Agent will populate]_'}
+
+---
+
+## Change Log
+
+| Date | Version | Description | Author |
+|------|---------|-------------|--------|
+| ${currentDate} | 1.0 | Story created | AI Agent |
+`;
+    }
+    /**
+     * Check if a layer should be skipped due to failed dependencies
+     */
+    shouldSkipLayer(layer, taskMap, taskResults) {
+        const completedTaskIds = new Set(taskResults.filter((r) => r.success).map((r) => r.taskId));
+        for (const taskId of layer) {
+            const task = taskMap.get(taskId);
+            if (!task)
+                continue;
+            // Check if all dependencies succeeded
+            for (const depId of task.dependencies) {
+                if (!completedTaskIds.has(depId)) {
+                    return true; // Dependency not completed successfully
+                }
+            }
+        }
+        return false;
+    }
+}