@hyperdrive.bot/bmad-workflow 1.0.2

package/dist/commands/stories/list.js

@@ -0,0 +1,291 @@
+/**
+ * Stories List Command
+ *
+ * Lists all stories with filtering by status and epic number.
+ * Displays results in table format or JSON format with counts summary.
+ *
+ * @example
+ * ```bash
+ * bmad-workflow stories list
+ * bmad-workflow stories list --status=draft
+ * bmad-workflow stories list --epic=4
+ * bmad-workflow stories list --status=ready --epic=4 --json
+ * ```
+ */
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { isEpicStory } from '../../models/story.js';
+import { FileManager } from '../../services/file-system/file-manager.js';
+import { PathResolver } from '../../services/file-system/path-resolver.js';
+import { StoryParserFactory } from '../../services/parsers/story-parser-factory.js';
+import { FileSystemError } from '../../utils/errors.js';
+import { createLogger } from '../../utils/logger.js';
+/**
+ * Stories List Command
+ *
+ * Lists all stories with optional filtering by status and epic number.
+ */
+export default class StoriesListCommand extends Command {
+    static description = 'List all stories with optional filtering by status and epic';
+    static examples = [
+        {
+            command: '<%= config.bin %> <%= command.id %>',
+            description: 'List all stories',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --status=draft',
+            description: 'List only draft stories',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --epic=4',
+            description: 'List stories from epic 4',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> --status=ready --epic=4 --json',
+            description: 'List ready stories from epic 4 as JSON',
+        },
+    ];
+    static flags = {
+        epic: Flags.integer({
+            description: 'Filter by epic number',
+        }),
+        json: Flags.boolean({
+            description: 'Output results as JSON',
+        }),
+        status: Flags.string({
+            description: 'Filter by story status (draft, ready, done)',
+            options: ['draft', 'ready', 'done', 'inprogress', 'failed'],
+        }),
+    };
+    // Service instances
+    fileManager;
+    logger;
+    pathResolver;
+    storyParserFactory;
+    /**
+     * Run command
+     */
+    async run() {
+        const { flags } = await this.parse(StoriesListCommand);
+        // Initialize services
+        this.initServices();
+        this.logger.info('Listing stories with filters: status=%s, epic=%s', flags.status, flags.epic);
+        try {
+            // Get story directory from PathResolver
+            const storyDir = this.pathResolver.getStoryDir();
+            this.logger.debug('Story directory: %s', storyDir);
+            // Read directory contents
+            const files = await this.fileManager.listFiles(storyDir, '*.md');
+            this.logger.info('Found %d markdown files in story directory', files.length);
+            // Parse story metadata from each file
+            const stories = await this.parseStories(files);
+            this.logger.info('Successfully parsed %d stories', stories.length);
+            // Apply filters
+            let filtered = this.applyFilters(stories, flags);
+            // Sort by story number
+            filtered = this.sortStories(filtered);
+            this.logger.info('After filtering and sorting: %d stories', filtered.length);
+            // Output results
+            if (flags.json) {
+                this.outputJson(filtered);
+            }
+            else {
+                this.outputTable(filtered);
+            }
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Apply filters to stories
+     */
+    applyFilters(stories, flags) {
+        let filtered = stories;
+        // Filter by status
+        if (flags.status) {
+            filtered = filtered.filter((s) => s.status.toLowerCase() === flags.status.toLowerCase());
+            this.logger.debug('After status filter (%s): %d stories', flags.status, filtered.length);
+        }
+        // Filter by epic number (only applies to epic-based stories)
+        if (flags.epic !== undefined) {
+            filtered = filtered.filter((s) => isEpicStory(s) && s.epicNumber === flags.epic);
+            this.logger.debug('After epic filter (%d): %d stories', flags.epic, filtered.length);
+        }
+        return filtered;
+    }
+    /**
+     * Display count summary
+     */
+    displaySummary(stories) {
+        // Count by status
+        const statusCounts = {};
+        for (const story of stories) {
+            const status = story.status.toLowerCase();
+            statusCounts[status] = (statusCounts[status] || 0) + 1;
+        }
+        // Build summary message
+        const summaryParts = Object.entries(statusCounts)
+            .map(([status, count]) => `${count} ${status}`)
+            .join(', ');
+        this.log('');
+        this.log(chalk.white(`Found ${stories.length} stories: ${summaryParts}`));
+        this.log('');
+    }
+    /**
+     * Get color for status
+     */
+    getStatusColor(status) {
+        switch (status.toLowerCase()) {
+            case 'done': {
+                return 'green';
+            }
+            case 'draft': {
+                return 'yellow';
+            }
+            case 'failed': {
+                return 'red';
+            }
+            case 'ready': {
+                return 'blue';
+            }
+            default: {
+                return 'gray';
+            }
+        }
+    }
+    /**
+     * Handle errors with user-friendly messages
+     */
+    handleError(error) {
+        this.logger.error('Error listing stories: %O', error);
+        if (error instanceof FileSystemError) {
+            const fsError = error;
+            if (error.message.includes('does not exist')) {
+                this.error(`Story directory not found: ${fsError.context?.dirPath || 'unknown'}\n` +
+                    'Check your .bmad-core/core-config.yaml configuration.', { exit: 1 });
+            }
+            if (error.message.includes('permission denied')) {
+                this.error(`Permission denied reading story directory: ${fsError.context?.dirPath || 'unknown'}\n` +
+                    'Check file permissions and try again.', { exit: 1 });
+            }
+        }
+        this.error(`Failed to list stories: ${error.message}`, { exit: 1 });
+    }
+    /**
+     * Initialize services
+     */
+    initServices() {
+        this.logger = createLogger({ namespace: 'commands:stories:list' });
+        this.fileManager = new FileManager(this.logger);
+        this.pathResolver = new PathResolver(this.fileManager, this.logger);
+        this.storyParserFactory = new StoryParserFactory(this.fileManager, this.logger);
+    }
+    /**
+     * Output stories as JSON
+     */
+    outputJson(stories) {
+        const output = stories.map((story) => {
+            const base = {
+                filePath: story.filePath,
+                id: story.id,
+                status: story.status,
+                title: story.title,
+                type: story.type,
+            };
+            if (isEpicStory(story)) {
+                return {
+                    ...base,
+                    epic: story.epicNumber,
+                    number: story.number,
+                    storyNumber: story.storyNumber,
+                };
+            }
+            return {
+                ...base,
+                category: story.category,
+            };
+        });
+        this.log(JSON.stringify(output, null, 2));
+    }
+    /**
+     * Output stories as table
+     */
+    outputTable(stories) {
+        if (stories.length === 0) {
+            this.log(chalk.yellow('No stories found matching criteria'));
+            return;
+        }
+        // Create simple table
+        this.log('');
+        this.log(chalk.cyan.bold('Story ID'.padEnd(30)) +
+            chalk.cyan.bold('Title'.padEnd(45)) +
+            chalk.cyan.bold('Status'.padEnd(15)) +
+            chalk.cyan.bold('Type'));
+        this.log(chalk.gray('─'.repeat(100)));
+        // Add rows
+        for (const story of stories) {
+            const statusColor = this.getStatusColor(story.status);
+            const truncatedTitle = this.truncate(story.title, 43);
+            const storyId = isEpicStory(story) ? story.number : story.id;
+            const typeLabel = isEpicStory(story) ? `Epic ${story.epicNumber}` : story.category || 'Standalone';
+            this.log(storyId.padEnd(30) +
+                truncatedTitle.padEnd(45) +
+                chalk[statusColor](story.status.padEnd(15)) +
+                chalk.gray(typeLabel));
+        }
+        // Display summary
+        this.displaySummary(stories);
+    }
+    /**
+     * Parse stories from file paths
+     */
+    async parseStories(files) {
+        const stories = [];
+        for (const file of files) {
+            try {
+                // Sequential parsing to maintain order and reduce memory usage
+                // eslint-disable-next-line no-await-in-loop
+                const metadata = await this.storyParserFactory.parseStory(file);
+                stories.push(metadata);
+            }
+            catch (error) {
+                this.logger.warn({ err: error, file }, 'Failed to parse story');
+                // Continue processing other files
+            }
+        }
+        return stories;
+    }
+    /**
+     * Sort stories by type and ID
+     *
+     * Epic stories are sorted by epic.story number ascending.
+     * Standalone stories are sorted alphabetically by ID.
+     * Epic stories appear before standalone stories.
+     */
+    sortStories(stories) {
+        return stories.sort((a, b) => {
+            // Epic stories come before standalone stories
+            if (isEpicStory(a) && !isEpicStory(b))
+                return -1;
+            if (!isEpicStory(a) && isEpicStory(b))
+                return 1;
+            // Both epic stories: sort by epic.story number
+            if (isEpicStory(a) && isEpicStory(b)) {
+                // Compare epic numbers first
+                if (a.epicNumber !== b.epicNumber)
+                    return a.epicNumber - b.epicNumber;
+                // Then compare story numbers
+                return a.storyNumber - b.storyNumber;
+            }
+            // Both standalone: sort alphabetically by ID
+            return a.id.localeCompare(b.id);
+        });
+    }
+    /**
+     * Truncate string to max length
+     */
+    truncate(str, maxLength) {
+        return str.length > maxLength ? str.slice(0, maxLength - 3) + '...' : str;
+    }
+}

package/dist/commands/stories/move.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Stories Move Command
+ *
+ * Moves story files from active stories directory to QA directory.
+ * Supports glob patterns for selecting multiple files and requires confirmation
+ * unless --force flag is used.
+ *
+ * @example
+ * ```bash
+ * bmad-workflow stories move "4.7-*.md"
+ * bmad-workflow stories move "4.*-*.md" --force
+ * bmad-workflow stories move "*.md"
+ * ```
+ */
+import { Command } from '@oclif/core';
+/**
+ * Stories Move Command
+ *
+ * Moves story files from active directory (docs/stories) to QA directory (docs/qa/stories).
+ * Provides confirmation before moving (unless --force flag is used) and displays progress.
+ */
+export default class StoriesMoveCommand extends Command {
+    static args: {
+        pattern: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private fileManager;
+    private globMatcher;
+    private logger;
+    private pathResolver;
+    /**
+     * Run command
+     */
+    run(): Promise<void>;
+    /**
+     * Confirm move operation with user
+     */
+    private confirmMove;
+    /**
+     * Display list of files to be moved
+     */
+    private displayFileList;
+    /**
+     * Display summary of move operation
+     */
+    private displaySummary;
+    /**
+     * Handle errors with user-friendly messages
+     */
+    private handleError;
+    /**
+     * Initialize services
+     */
+    private initServices;
+    /**
+     * Move files from source to QA directory
+     */
+    private moveFiles;
+}

package/dist/commands/stories/move.js

@@ -0,0 +1,273 @@
+/**
+ * Stories Move Command
+ *
+ * Moves story files from active stories directory to QA directory.
+ * Supports glob patterns for selecting multiple files and requires confirmation
+ * unless --force flag is used.
+ *
+ * @example
+ * ```bash
+ * bmad-workflow stories move "4.7-*.md"
+ * bmad-workflow stories move "4.*-*.md" --force
+ * bmad-workflow stories move "*.md"
+ * ```
+ */
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import path from 'node:path';
+import * as readline from 'node:readline';
+import ora from 'ora';
+import { FileManager } from '../../services/file-system/file-manager.js';
+import { GlobMatcher } from '../../services/file-system/glob-matcher.js';
+import { PathResolver } from '../../services/file-system/path-resolver.js';
+import { FileSystemError } from '../../utils/errors.js';
+import { createLogger } from '../../utils/logger.js';
+/**
+ * Stories Move Command
+ *
+ * Moves story files from active directory (docs/stories) to QA directory (docs/qa/stories).
+ * Provides confirmation before moving (unless --force flag is used) and displays progress.
+ */
+export default class StoriesMoveCommand extends Command {
+    static args = {
+        pattern: Args.string({
+            description: 'Glob pattern to match story files (e.g., "4.7-*.md", "*.md")',
+            required: true,
+        }),
+    };
+    static description = 'Move story files from active to QA directory';
+    static examples = [
+        {
+            command: '<%= config.bin %> <%= command.id %> "4.7-*.md"',
+            description: 'Move all stories matching pattern 4.7-*.md',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> "4.*-*.md" --force',
+            description: 'Move all epic 4 stories without confirmation',
+        },
+        {
+            command: '<%= config.bin %> <%= command.id %> "STORY-123-*.md"',
+            description: 'Move specific story file',
+        },
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    // Service instances
+    fileManager;
+    globMatcher;
+    logger;
+    pathResolver;
+    /**
+     * Run command
+     */
+    async run() {
+        const { args, flags } = await this.parse(StoriesMoveCommand);
+        // Initialize services
+        this.initServices();
+        this.logger.info('Moving stories with pattern: %s, force: %s', args.pattern, flags.force);
+        try {
+            // Get directories from PathResolver
+            const storyDir = this.pathResolver.getStoryDir();
+            const qaStoryDir = this.pathResolver.getQaStoryDir();
+            this.logger.debug('Source directory: %s', storyDir);
+            this.logger.debug('Destination directory: %s', qaStoryDir);
+            // Expand pattern to find matching files
+            const fullPattern = path.join(storyDir, args.pattern);
+            const matchedFiles = await this.globMatcher.expandPattern(fullPattern);
+            // Filter to only include files in the stories directory
+            const filteredFiles = matchedFiles.filter((file) => file.startsWith(storyDir));
+            this.logger.info('Found %d files matching pattern', filteredFiles.length);
+            if (filteredFiles.length === 0) {
+                this.log(chalk.yellow(`No stories found matching pattern: ${args.pattern}`));
+                return;
+            }
+            // Display list of files to be moved
+            this.displayFileList(filteredFiles, storyDir);
+            // Get confirmation unless --force flag is set
+            if (flags.force) {
+                this.logger.info('Skipping confirmation due to --force flag');
+            }
+            else {
+                const confirmed = await this.confirmMove(filteredFiles.length);
+                if (!confirmed) {
+                    this.log(chalk.yellow('Operation cancelled'));
+                    this.logger.info('User cancelled operation');
+                    return;
+                }
+            }
+            // Move files
+            const results = await this.moveFiles(filteredFiles, storyDir, qaStoryDir);
+            // Display summary
+            this.displaySummary(results);
+            // Exit with appropriate code
+            const failed = results.filter((r) => r.status === 'failed').length;
+            if (failed > 0) {
+                this.logger.error('Move operation completed with %d failures', failed);
+                this.exit(1);
+            }
+            this.logger.info('Move operation completed successfully');
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Confirm move operation with user
+     */
+    async confirmMove(fileCount) {
+        this.log(''); // Blank line for spacing
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            rl.question(chalk.yellow(`Move ${fileCount} file${fileCount === 1 ? '' : 's'} to QA directory? (Y/N) `), (answer) => {
+                rl.close();
+                const normalized = answer.trim().toLowerCase();
+                resolve(normalized === 'y' || normalized === 'yes');
+            });
+        });
+    }
+    /**
+     * Display list of files to be moved
+     */
+    displayFileList(files, baseDir) {
+        this.log('');
+        this.log(chalk.cyan.bold('Files to be moved:'));
+        for (const file of files) {
+            const relativePath = path.relative(baseDir, file);
+            this.log(chalk.white(`  - ${relativePath}`));
+        }
+    }
+    /**
+     * Display summary of move operation
+     */
+    displaySummary(results) {
+        const moved = results.filter((r) => r.status === 'moved').length;
+        const skipped = results.filter((r) => r.status === 'skipped').length;
+        const failed = results.filter((r) => r.status === 'failed').length;
+        this.log('');
+        this.log(chalk.white('─'.repeat(60)));
+        this.log(chalk.bold('Move Summary:'));
+        if (moved > 0) {
+            this.log(chalk.green(`  ✓ Moved: ${moved} file${moved === 1 ? '' : 's'}`));
+        }
+        if (skipped > 0) {
+            this.log(chalk.yellow(`  ⚠ Skipped: ${skipped} file${skipped === 1 ? '' : 's'}`));
+        }
+        if (failed > 0) {
+            this.log(chalk.red(`  ✗ Failed: ${failed} file${failed === 1 ? '' : 's'}`));
+        }
+        this.log(chalk.white('─'.repeat(60)));
+        this.log('');
+        // Log skipped files with reasons
+        const skippedResults = results.filter((r) => r.status === 'skipped');
+        if (skippedResults.length > 0) {
+            this.log(chalk.yellow.bold('Skipped files:'));
+            for (const result of skippedResults) {
+                this.log(chalk.yellow(`  ${path.basename(result.source)}: ${result.reason || 'Unknown reason'}`));
+            }
+            this.log('');
+        }
+        // Log failed files with errors
+        const failedResults = results.filter((r) => r.status === 'failed');
+        if (failedResults.length > 0) {
+            this.log(chalk.red.bold('Failed files:'));
+            for (const result of failedResults) {
+                this.log(chalk.red(`  ${path.basename(result.source)}: ${result.error || 'Unknown error'}`));
+            }
+            this.log('');
+        }
+    }
+    /**
+     * Handle errors with user-friendly messages
+     */
+    handleError(error) {
+        this.logger.error('Error moving stories: %O', error);
+        if (error instanceof FileSystemError) {
+            const fsError = error;
+            if (error.message.includes('does not exist')) {
+                this.error(`Directory not found: ${fsError.context?.dirPath || 'unknown'}\n` +
+                    'Check your .bmad-core/core-config.yaml configuration.', { exit: 1 });
+            }
+            if (error.message.includes('permission denied')) {
+                this.error(`Permission denied: ${fsError.context?.dirPath || 'unknown'}\nCheck file permissions and try again.`, { exit: 1 });
+            }
+            if (error.message.includes('Glob pattern cannot be empty')) {
+                this.error('Pattern cannot be empty. Please provide a valid glob pattern.', { exit: 1 });
+            }
+        }
+        this.error(`Failed to move stories: ${error.message}`, { exit: 1 });
+    }
+    /**
+     * Initialize services
+     */
+    initServices() {
+        this.logger = createLogger({ namespace: 'commands:stories:move' });
+        this.fileManager = new FileManager(this.logger);
+        this.pathResolver = new PathResolver(this.fileManager, this.logger);
+        this.globMatcher = new GlobMatcher(this.fileManager, this.logger);
+    }
+    /**
+     * Move files from source to QA directory
+     */
+    async moveFiles(files, sourceDir, destDir) {
+        const results = [];
+        const spinner = ora('Moving files...').start();
+        // Process files sequentially to show progress for each file
+        /* eslint-disable no-await-in-loop */
+        for (const sourceFile of files) {
+            const fileName = path.basename(sourceFile);
+            const destFile = path.join(destDir, fileName);
+            spinner.text = `Moving ${fileName}...`;
+            this.logger.info('Moving file: %s -> %s', sourceFile, destFile);
+            try {
+                // Check if destination file exists
+                const destExists = await this.fileManager.fileExists(destFile);
+                if (destExists) {
+                    spinner.warn(chalk.yellow(`Skipped ${fileName} (file already exists in destination)`));
+                    this.logger.warn('Destination file already exists: %s', destFile);
+                    results.push({
+                        destination: destFile,
+                        reason: 'File already exists in destination',
+                        source: sourceFile,
+                        status: 'skipped',
+                    });
+                    continue;
+                }
+                // Move file
+                await this.fileManager.moveFile(sourceFile, destFile);
+                spinner.succeed(chalk.green(`✓ Moved ${fileName}`));
+                this.logger.info('Successfully moved file: %s -> %s', sourceFile, destFile);
+                results.push({
+                    destination: destFile,
+                    source: sourceFile,
+                    status: 'moved',
+                });
+            }
+            catch (error) {
+                const err = error;
+                spinner.fail(chalk.red(`✗ Failed to move ${fileName}: ${err.message}`));
+                this.logger.error('Error moving file %s: %O', sourceFile, err);
+                results.push({
+                    destination: destFile,
+                    error: err.message,
+                    source: sourceFile,
+                    status: 'failed',
+                });
+            }
+            // Restart spinner for next iteration
+            if (files.indexOf(sourceFile) < files.length - 1) {
+                spinner.start();
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        spinner.stop();
+        return results;
+    }
+}