@hyperdrive.bot/bmad-workflow 1.0.17 → 1.0.19

package/dist/services/validation/config-validator.js

@@ -7,6 +7,77 @@
  */
 import { z } from 'zod';
 import { ValidationError } from '../../utils/errors.js';
+/**
+ * Valid scanner identifiers for automated code review
+ */
+const VALID_SCANNERS = ['ai', 'lint', 'coderabbit'];
+/**
+ * Valid severity levels
+ */
+const VALID_SEVERITIES = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW'];
+/**
+ * Zod schema for review.severity configuration
+ */
+const severityArraySchema = z.array(z.enum(VALID_SEVERITIES, {
+    message: `Invalid severity level. Valid values: ${VALID_SEVERITIES.join(', ')}`,
+}));
+/**
+ * Zod schema for review.pathRules entries
+ */
+const pathRuleSchema = z.object({
+    focus: z.string().min(1, { message: 'Path rule focus description is required' }),
+    pattern: z.string().min(1, { message: 'Path rule pattern is required' }),
+});
+/**
+ * Zod schema for review configuration section
+ *
+ * Defines scanners, severity thresholds, self-heal limits, and path rules
+ * for automated code review in the BMAD workflow pipeline.
+ */
+export const reviewConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    pathRules: z.array(pathRuleSchema).optional(),
+    scanners: z
+        .array(z.enum(VALID_SCANNERS, {
+        message: `Unknown scanner name. Valid values: ${VALID_SCANNERS.join(', ')}`,
+    }))
+        .default(['ai', 'lint']),
+    selfHeal: z
+        .object({
+        fixAgent: z.string().default('dev'),
+        fixTimeout: z.number().int().positive({ message: 'selfHeal.fixTimeout must be a positive integer' }).default(300_000),
+        maxIterations: z
+            .number()
+            .int()
+            .positive({ message: 'selfHeal.maxIterations must be a positive integer' })
+            .default(3),
+    })
+        .default(() => ({ fixAgent: 'dev', fixTimeout: 300_000, maxIterations: 3 })),
+    severity: z
+        .object({
+        blockOn: severityArraySchema.default(['CRITICAL', 'HIGH']),
+        documentOn: severityArraySchema.default(['MEDIUM']),
+        ignoreOn: severityArraySchema.default(['LOW']),
+    })
+        .default(() => ({
+        blockOn: ['CRITICAL', 'HIGH'],
+        documentOn: ['MEDIUM'],
+        ignoreOn: ['LOW'],
+    })),
+})
+    .superRefine((data, ctx) => {
+    // Validate that blockOn and ignoreOn do not overlap
+    const blockSet = new Set(data.severity.blockOn);
+    const overlapping = data.severity.ignoreOn.filter((s) => blockSet.has(s));
+    if (overlapping.length > 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `severity.blockOn and severity.ignoreOn must not overlap. Overlapping: ${overlapping.join(', ')}`,
+            path: ['severity'],
+        });
+    }
+});
 /**
  * Zod schema for core configuration
  *
@@ -25,6 +96,7 @@ const configSchema = z.object({
         qaLocation: z.string().optional(),
     })
         .optional(),
+    review: reviewConfigSchema.optional(),
 });
 /**
  * ConfigValidator service validates configuration files against schemas
@@ -105,11 +177,17 @@ export class ConfigValidator {
             devStoryLocation: 'docs/stories',
             'prd.prdFile': 'docs/prd.md',
             'qa.qaLocation': 'docs/qa',
+            'review.scanners': '[ai, lint]',
+            'review.severity.blockOn': '[CRITICAL, HIGH]',
+            'review.selfHeal.maxIterations': '3',
         };
         const fieldDisplayNames = {
             devStoryLocation: 'Story directory path (devStoryLocation)',
             'prd.prdFile': 'PRD file path (prd.prdFile)',
             'qa.qaLocation': 'QA location path (qa.qaLocation)',
+            'review.scanners': 'Review scanners (review.scanners)',
+            'review.severity.blockOn': 'Review severity blockOn (review.severity.blockOn)',
+            'review.selfHeal.maxIterations': 'Self-heal max iterations (review.selfHeal.maxIterations)',
         };
         const example = examples[fieldName] || 'path/to/directory';
         const displayName = fieldDisplayNames[fieldName] || fieldName;

package/dist/utils/colors.d.ts

@@ -1,36 +1,36 @@
 /**
- * Format a success message with green color and checkmark icon
+ * Format a success message with checkmark icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ✓ icon
+ * @returns Formatted string with ✓ icon
  */
 export declare const success: (text: string) => string;
 /**
- * Format an error message with red color and X icon
+ * Format an error message with X icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ✗ icon
+ * @returns Formatted string with ✗ icon
  */
 export declare const error: (text: string) => string;
 /**
- * Format a warning message with yellow color and warning icon
+ * Format a warning message with warning icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ⚠ icon
+ * @returns Formatted string with ⚠ icon
  */
 export declare const warning: (text: string) => string;
 /**
- * Format an info message with blue color and info icon
+ * Format an info message with info icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ℹ icon
+ * @returns Formatted string with ℹ icon
  */
 export declare const info: (text: string) => string;
 /**
- * Highlight text with cyan color for emphasis
+ * Highlight text for emphasis
  *
  * @param text - Text to highlight
- * @returns Formatted string with ANSI color codes
+ * @returns Formatted string with ANSI bold codes
  */
 export declare const highlight: (text: string) => string;
 /**

package/dist/utils/colors.js

@@ -1,39 +1,39 @@
 import chalk from 'chalk';
 /**
- * Format a success message with green color and checkmark icon
+ * Format a success message with checkmark icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ✓ icon
+ * @returns Formatted string with ✓ icon
  */
-export const success = (text) => chalk.green(`✓ ${text}`);
+export const success = (text) => chalk.bold(`✓ ${text}`);
 /**
- * Format an error message with red color and X icon
+ * Format an error message with X icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ✗ icon
+ * @returns Formatted string with ✗ icon
  */
-export const error = (text) => chalk.red(`✗ ${text}`);
+export const error = (text) => chalk.bold(`✗ ${text}`);
 /**
- * Format a warning message with yellow color and warning icon
+ * Format a warning message with warning icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ⚠ icon
+ * @returns Formatted string with ⚠ icon
  */
-export const warning = (text) => chalk.yellow(`⚠ ${text}`);
+export const warning = (text) => chalk.bold(`⚠ ${text}`);
 /**
- * Format an info message with blue color and info icon
+ * Format an info message with info icon
  *
  * @param text - Message text to format
- * @returns Formatted string with ANSI color codes and ℹ icon
+ * @returns Formatted string with ℹ icon
  */
-export const info = (text) => chalk.blue(`ℹ ${text}`);
+export const info = (text) => `ℹ ${text}`;
 /**
- * Highlight text with cyan color for emphasis
+ * Highlight text for emphasis
  *
  * @param text - Text to highlight
- * @returns Formatted string with ANSI color codes
+ * @returns Formatted string with ANSI bold codes
  */
-export const highlight = (text) => chalk.cyan(text);
+export const highlight = (text) => chalk.bold(text);
 /**
  * Format text in bold style
  *

package/dist/utils/credential-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Credential utility functions
+ *
+ * Shared helpers for credential display masking.
+ */
+/**
+ * Mask a credential value for display.
+ * Shows first 3 chars + '***...***' + last 3 chars.
+ * For values shorter than 8 chars, mask entirely as '***'.
+ *
+ * @param value - The raw credential value
+ * @returns Masked string safe for display
+ */
+export declare function maskValue(value: string): string;

package/dist/utils/credential-utils.js

@@ -0,0 +1,19 @@
+/**
+ * Credential utility functions
+ *
+ * Shared helpers for credential display masking.
+ */
+/**
+ * Mask a credential value for display.
+ * Shows first 3 chars + '***...***' + last 3 chars.
+ * For values shorter than 8 chars, mask entirely as '***'.
+ *
+ * @param value - The raw credential value
+ * @returns Masked string safe for display
+ */
+export function maskValue(value) {
+    if (value.length < 8) {
+        return '***';
+    }
+    return `${value.slice(0, 3)}***...***${value.slice(-3)}`;
+}

package/dist/utils/duration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Duration Parsing Utility
+ *
+ * Parses human-readable duration strings (e.g., "30s", "5m", "1h", "90m")
+ * into milliseconds. Also accepts raw millisecond numbers for backward
+ * compatibility with existing --timeout flag usage.
+ *
+ * @example
+ * ```typescript
+ * parseDuration('30s')      // 30_000
+ * parseDuration('5m')       // 300_000
+ * parseDuration('45m')      // 2_700_000
+ * parseDuration('1h')       // 3_600_000
+ * parseDuration('1.5h')     // 5_400_000
+ * parseDuration('2700000')  // 2_700_000 (raw ms, backward compat)
+ * parseDuration(2700000)    // 2_700_000 (numeric passthrough)
+ * ```
+ */
+/**
+ * Parse a duration string or number into milliseconds.
+ *
+ * Accepted formats:
+ * - `"30s"` — seconds
+ * - `"5m"` — minutes
+ * - `"1h"` — hours
+ * - `"1.5h"` — fractional units
+ * - `"2700000"` — raw milliseconds (string)
+ * - `2700000` — raw milliseconds (number)
+ *
+ * @param input - Duration string or number
+ * @returns Duration in milliseconds
+ * @throws Error if the input format is invalid or value is non-positive
+ */
+export declare function parseDuration(input: number | string): number;
+/**
+ * Format a millisecond duration into a human-readable string.
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Formatted string (e.g., "45m", "1.5h", "30s")
+ */
+export declare function formatDuration(ms: number): string;

package/dist/utils/duration.js

@@ -0,0 +1,89 @@
+/**
+ * Duration Parsing Utility
+ *
+ * Parses human-readable duration strings (e.g., "30s", "5m", "1h", "90m")
+ * into milliseconds. Also accepts raw millisecond numbers for backward
+ * compatibility with existing --timeout flag usage.
+ *
+ * @example
+ * ```typescript
+ * parseDuration('30s')      // 30_000
+ * parseDuration('5m')       // 300_000
+ * parseDuration('45m')      // 2_700_000
+ * parseDuration('1h')       // 3_600_000
+ * parseDuration('1.5h')     // 5_400_000
+ * parseDuration('2700000')  // 2_700_000 (raw ms, backward compat)
+ * parseDuration(2700000)    // 2_700_000 (numeric passthrough)
+ * ```
+ */
+/** Duration unit multipliers in milliseconds */
+const UNIT_MS = {
+    h: 3_600_000,
+    m: 60_000,
+    s: 1_000,
+};
+/**
+ * Parse a duration string or number into milliseconds.
+ *
+ * Accepted formats:
+ * - `"30s"` — seconds
+ * - `"5m"` — minutes
+ * - `"1h"` — hours
+ * - `"1.5h"` — fractional units
+ * - `"2700000"` — raw milliseconds (string)
+ * - `2700000` — raw milliseconds (number)
+ *
+ * @param input - Duration string or number
+ * @returns Duration in milliseconds
+ * @throws Error if the input format is invalid or value is non-positive
+ */
+export function parseDuration(input) {
+    // Numeric passthrough
+    if (typeof input === 'number') {
+        if (input <= 0 || !Number.isFinite(input)) {
+            throw new Error(`Invalid timeout value: ${input}. Must be a positive number.`);
+        }
+        return Math.round(input);
+    }
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Timeout value cannot be empty.');
+    }
+    // Try matching duration pattern: number + unit suffix
+    const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(s|m|h)$/i);
+    if (match) {
+        const value = Number.parseFloat(match[1]);
+        const unit = match[2].toLowerCase();
+        const multiplier = UNIT_MS[unit];
+        const ms = Math.round(value * multiplier);
+        if (ms <= 0) {
+            throw new Error(`Invalid timeout value: ${trimmed}. Must result in a positive duration.`);
+        }
+        return ms;
+    }
+    // Try raw numeric string (milliseconds)
+    const numeric = Number(trimmed);
+    if (!Number.isNaN(numeric) && Number.isFinite(numeric) && numeric > 0) {
+        return Math.round(numeric);
+    }
+    throw new Error(`Invalid timeout format: "${trimmed}". ` +
+        `Expected a duration like "30s", "5m", "1h", "90m", or raw milliseconds like "2700000".`);
+}
+/**
+ * Format a millisecond duration into a human-readable string.
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Formatted string (e.g., "45m", "1.5h", "30s")
+ */
+export function formatDuration(ms) {
+    if (ms >= 3_600_000) {
+        const hours = ms / 3_600_000;
+        return Number.isInteger(hours) ? `${hours}h` : `${hours.toFixed(1)}h`;
+    }
+    if (ms >= 60_000) {
+        const minutes = ms / 60_000;
+        return Number.isInteger(minutes) ? `${minutes}m` : `${minutes.toFixed(1)}m`;
+    }
+    const seconds = ms / 1_000;
+    return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(1)}s`;
+}

package/dist/utils/listr2-helpers.d.ts

@@ -0,0 +1,216 @@
+/**
+ * listr2 Helper Functions
+ *
+ * Utility functions for creating and managing listr2 task structures
+ * used by the WorkflowReporter for visualizing workflow progress.
+ */
+/**
+ * Default terminal width constraint for output formatting
+ */
+export declare const DEFAULT_TERMINAL_WIDTH = 80;
+/**
+ * Regex pattern for detecting ANSI escape codes
+ */
+export declare const ANSI_ESCAPE_PATTERN: RegExp;
+/**
+ * Strip ANSI escape codes from text
+ *
+ * @param text - Text potentially containing ANSI codes
+ * @returns Clean text without ANSI escape sequences
+ */
+export declare const stripAnsi: (text: string) => string;
+/**
+ * Check if the current environment is a TTY
+ *
+ * @returns true if stdout is a TTY, false otherwise
+ */
+export declare const isTTY: () => boolean;
+/**
+ * Plain-text status indicators (no ANSI codes)
+ */
+export declare const PLAIN_STATUS_INDICATORS: {
+    readonly completed: "[+]";
+    readonly failed: "[X]";
+    readonly queued: "[.]";
+    readonly running: "[*]";
+};
+/**
+ * Format a plain-text phase header for non-TTY output
+ *
+ * @param phaseName - Phase name (epic, story, dev, qa)
+ * @returns Plain-text header string (e.g., "=== Phase: Epic Generation ===")
+ */
+export declare const formatPlainPhaseHeader: (phaseName: string) => string;
+/**
+ * Format a plain-text spawn marker for non-TTY output
+ *
+ * @param itemId - Item identifier
+ * @param status - Spawn status (STARTED, COMPLETED, FAILED)
+ * @param durationMs - Optional duration in milliseconds
+ * @param error - Optional error message for failed spawns
+ * @returns Plain-text marker string (e.g., "[SPAWN] story-1.001 STARTED")
+ */
+export declare const formatPlainSpawnMarker: (itemId: string, status: "COMPLETED" | "FAILED" | "STARTED", durationMs?: number, error?: string) => string;
+/**
+ * Format a plain-text summary for non-TTY output
+ *
+ * @param totalSpawns - Total number of spawns
+ * @param passedCount - Number of passed spawns
+ * @param failedCount - Number of failed spawns
+ * @param durationMs - Total duration in milliseconds
+ * @returns Plain-text summary string
+ */
+export declare const formatPlainSummary: (totalSpawns: number, passedCount: number, failedCount: number, durationMs: number) => string;
+/**
+ * Format spawn output with visual delimiters for verbose mode
+ *
+ * @param spawnId - Spawn identifier
+ * @param output - Output content from the spawn
+ * @param maxWidth - Maximum line width (default: 80)
+ * @returns Formatted output with header/footer delimiters
+ */
+export declare const formatVerboseSpawnOutput: (spawnId: string, output: string, maxWidth?: number) => string;
+/**
+ * Wrap text lines to fit within a maximum width
+ *
+ * @param text - Text to wrap
+ * @param maxWidth - Maximum line width
+ * @returns Wrapped text
+ */
+export declare const wrapLines: (text: string, maxWidth: number) => string;
+/**
+ * Phase emoji mapping for visual consistency
+ */
+export declare const PHASE_EMOJI: Record<string, string>;
+/**
+ * Phase display names for titles
+ */
+export declare const PHASE_TITLES: Record<string, string>;
+/**
+ * Action verbs for spawn labels — maps phase to what the spawn is DOING (lowercase)
+ */
+export declare const PHASE_ACTION_VERBS: Record<string, string>;
+/**
+ * Get the action verb for a phase (e.g., "Creating" for story phase)
+ */
+export declare const getPhaseActionVerb: (phaseName: string) => string;
+/**
+ * Status indicators for spawn states
+ */
+export declare const STATUS_INDICATORS: {
+    readonly completed: string;
+    readonly failed: string;
+    readonly queued: string;
+    readonly running: string;
+};
+/**
+ * Get emoji for a phase name
+ *
+ * @param phaseName - Phase name (epic, story, dev, qa)
+ * @returns Emoji string for the phase
+ */
+export declare const getPhaseEmoji: (phaseName: string) => string;
+/**
+ * Create a formatted phase title with emoji
+ *
+ * @param phaseName - Phase name (epic, story, dev, qa)
+ * @returns Formatted title string with emoji (e.g., "📋 Epic Phase")
+ */
+export declare const createPhaseTitle: (phaseName: string) => string;
+/**
+ * Create a phase task group configuration for listr2
+ *
+ * @param phaseName - Phase name (epic, story, dev, qa)
+ * @returns Object with title and phase metadata
+ */
+export declare const createPhaseTaskGroup: (phaseName: string) => {
+    emoji: string;
+    phaseName: string;
+    title: string;
+};
+/**
+ * Create a layer task group configuration for listr2
+ *
+ * @param layerIndex - Zero-based layer index
+ * @param spawnCount - Number of spawns in the layer
+ * @param totalLayers - Total number of layers in the phase
+ * @returns Object with title and layer metadata
+ */
+export declare const createLayerTaskGroup: (layerIndex: number, spawnCount: number, totalLayers: number) => {
+    layerIndex: number;
+    spawnCount: number;
+    title: string;
+    totalLayers: number;
+};
+/**
+ * Spawn status type
+ */
+export type SpawnStatus = 'completed' | 'failed' | 'queued' | 'running';
+/**
+ * Format spawn status for display
+ *
+ * @param status - Current spawn status
+ * @param durationMs - Duration in milliseconds (optional)
+ * @param itemCount - Number of items processed (optional, for completed status)
+ * @param errorMessage - Error message (optional, for failed status)
+ * @returns Formatted status string
+ */
+export declare const formatSpawnStatus: (status: SpawnStatus, durationMs?: number, itemCount?: number, errorMessage?: string) => string;
+/**
+ * Layer result summary
+ */
+export interface LayerResult {
+    durationMs: number;
+    failureCount: number;
+    layerIndex: number;
+    spawnCount: number;
+    successCount: number;
+}
+/**
+ * Format a layer summary line for collapsed display
+ *
+ * @param result - Layer execution results
+ * @returns Formatted summary string
+ */
+export declare const formatLayerSummary: (result: LayerResult) => string;
+/**
+ * Phase result summary
+ */
+export interface PhaseResult {
+    durationMs: number;
+    failureCount: number;
+    itemCount: number;
+    phaseName: string;
+    successCount: number;
+}
+/**
+ * Format a phase summary for completion display
+ *
+ * @param result - Phase execution results
+ * @returns Formatted summary string
+ */
+export declare const formatPhaseSummary: (result: PhaseResult) => string;
+/**
+ * Create a spawn task title
+ *
+ * @param itemId - Item identifier (epic number, story number, etc.)
+ * @param itemTitle - Optional item title/description
+ * @param agentType - Type of agent being spawned
+ * @returns Formatted spawn task title
+ */
+export declare const createSpawnTitle: (itemId: string, itemTitle?: string, agentType?: string) => string;
+/**
+ * Truncate a string to a maximum length with ellipsis
+ *
+ * @param text - Text to truncate
+ * @param maxLength - Maximum length (default: 60)
+ * @returns Truncated string with ellipsis if needed
+ */
+export declare const truncateText: (text: string, maxLength?: number) => string;
+/**
+ * Format elapsed time for running tasks (updates every second)
+ *
+ * @param startTime - Start timestamp in milliseconds
+ * @returns Formatted elapsed time string
+ */
+export declare const formatElapsedTime: (startTime: number) => string;