@eddacraft/anvil-adapters 0.1.0

package/dist/base/utils.js

@@ -0,0 +1,254 @@
+import { createHash } from 'node:crypto';
+export function generateDeterministicPlanId(content) {
+    const hash = createHash('sha256').update(content, 'utf8').digest('hex');
+    return `aps-${hash.substring(0, 8)}`;
+}
+/**
+ * Create a detection result
+ *
+ * @param detected - Whether format was detected
+ * @param confidence - Confidence score (0-100)
+ * @param reason - Optional reason
+ * @returns Detection result
+ */
+export function createDetection(detected, confidence, reason) {
+    return {
+        detected,
+        confidence: Math.max(0, Math.min(100, confidence)),
+        reason,
+    };
+}
+/**
+ * Create an adapter error
+ *
+ * @param code - Error code
+ * @param message - Error message
+ * @param options - Additional options
+ * @returns Adapter error
+ */
+export function createError(code, message, options) {
+    return {
+        code,
+        message,
+        ...options,
+    };
+}
+/**
+ * Create an adapter warning
+ *
+ * @param code - Warning code
+ * @param message - Warning message
+ * @param options - Additional options
+ * @returns Adapter warning
+ */
+export function createWarning(code, message, options) {
+    return {
+        code,
+        message,
+        ...options,
+    };
+}
+/**
+ * Check if content matches a pattern
+ *
+ * Useful for format detection.
+ *
+ * @param content - Content to check
+ * @param patterns - Array of regex patterns or strings
+ * @returns Number of patterns matched (0 to patterns.length)
+ */
+export function matchesPatterns(content, patterns) {
+    let matches = 0;
+    for (const pattern of patterns) {
+        if (typeof pattern === 'string') {
+            if (content.includes(pattern)) {
+                matches++;
+            }
+        }
+        else {
+            if (pattern.test(content)) {
+                matches++;
+            }
+        }
+    }
+    return matches;
+}
+/**
+ * Calculate confidence score based on pattern matches
+ *
+ * @param matchCount - Number of patterns matched
+ * @param totalPatterns - Total number of patterns checked
+ * @param requiredMatches - Minimum matches for 100% confidence
+ * @returns Confidence score (0-100)
+ */
+export function calculateConfidence(matchCount, totalPatterns, requiredMatches = totalPatterns) {
+    if (matchCount === 0)
+        return 0;
+    if (matchCount >= requiredMatches)
+        return 100;
+    // Linear interpolation
+    return Math.round((matchCount / requiredMatches) * 100);
+}
+/**
+ * Extract file extension from filename or path
+ *
+ * @param filename - Filename or path
+ * @returns Extension (including dot) or empty string
+ */
+export function getExtension(filename) {
+    const match = filename.match(/\.[^.]+$/);
+    return match ? match[0] : '';
+}
+/**
+ * Normalize format identifier
+ *
+ * Removes leading dot and converts to lowercase.
+ *
+ * @param format - Format identifier or extension
+ * @returns Normalized format
+ */
+export function normalizeFormat(format) {
+    return format.toLowerCase().replace(/^\./, '');
+}
+/**
+ * Format errors for display
+ *
+ * @param errors - Array of errors
+ * @returns Formatted error string
+ */
+export function formatErrors(errors) {
+    return errors
+        .map((error) => {
+        let msg = `[${error.code}] ${error.message}`;
+        if (error.path) {
+            msg += ` (at ${error.path}`;
+            if (error.line !== undefined) {
+                msg += `:${error.line}`;
+                if (error.column !== undefined) {
+                    msg += `:${error.column}`;
+                }
+            }
+            msg += ')';
+        }
+        return msg;
+    })
+        .join('\n');
+}
+/**
+ * Format warnings for display
+ *
+ * @param warnings - Array of warnings
+ * @returns Formatted warning string
+ */
+export function formatWarnings(warnings) {
+    return warnings
+        .map((warning) => {
+        let msg = `[${warning.code}] ${warning.message}`;
+        if (warning.path) {
+            msg += ` (at ${warning.path}`;
+            if (warning.line !== undefined) {
+                msg += `:${warning.line}`;
+                if (warning.column !== undefined) {
+                    msg += `:${warning.column}`;
+                }
+            }
+            msg += ')';
+        }
+        return msg;
+    })
+        .join('\n');
+}
+/**
+ * Merge parse results
+ *
+ * Useful when parsing composite formats.
+ *
+ * @param results - Array of parse results
+ * @returns Merged result
+ */
+export function mergeParseResults(results) {
+    if (results.length === 0) {
+        return {
+            success: false,
+            errors: [createError('NO_RESULTS', 'No parse results to merge')],
+        };
+    }
+    if (results.length === 1) {
+        return results[0];
+    }
+    const allErrors = [];
+    const allWarnings = [];
+    let finalData = results[0].data;
+    for (const result of results) {
+        if (!result.success) {
+            if (result.errors) {
+                allErrors.push(...result.errors);
+            }
+        }
+        if (result.warnings) {
+            allWarnings.push(...result.warnings);
+        }
+        if (result.data) {
+            finalData = result.data;
+        }
+    }
+    if (allErrors.length > 0) {
+        return {
+            success: false,
+            errors: allErrors,
+            warnings: allWarnings.length > 0 ? allWarnings : undefined,
+        };
+    }
+    return {
+        success: true,
+        data: finalData,
+        warnings: allWarnings.length > 0 ? allWarnings : undefined,
+    };
+}
+/**
+ * Check if result has errors
+ *
+ * @param result - Parse or serialize result
+ * @returns True if result has errors
+ */
+export function hasErrors(result) {
+    return !result.success || (result.errors !== undefined && result.errors.length > 0);
+}
+/**
+ * Check if result has warnings
+ *
+ * @param result - Parse or serialize result
+ * @returns True if result has warnings
+ */
+export function hasWarnings(result) {
+    return result.warnings !== undefined && result.warnings.length > 0;
+}
+/**
+ * Extract first line from content (useful for format detection)
+ *
+ * @param content - Content string
+ * @returns First non-empty line or empty string
+ */
+export function getFirstLine(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return '';
+}
+/**
+ * Count occurrences of pattern in content
+ *
+ * @param content - Content to search
+ * @param pattern - Pattern to count
+ * @returns Number of occurrences
+ */
+export function countOccurrences(content, pattern) {
+    if (typeof pattern === 'string') {
+        return (content.match(new RegExp(pattern, 'g')) || []).length;
+    }
+    return (content.match(new RegExp(pattern.source, 'g')) || []).length;
+}

package/dist/bmad/format-adapter.d.ts

@@ -0,0 +1,76 @@
+/**
+ * BMAD Format Adapter
+ *
+ * FormatAdapter implementation for BMAD (Breakthrough Method for Agile AI-Driven Development) format.
+ * Handles PRD, Architecture, Epic, Story, and Agent documents.
+ */
+import { type APSPlan, type ValidationResult } from '@eddacraft/anvil-core';
+import { BaseFormatAdapter, type AdapterMetadata, type DetectionResult, type ParseResult, type SerializeResult, type ParseContext, type AdapterOptions, type PathDetectionHint } from '../base/types.js';
+/**
+ * BMAD FormatAdapter implementation
+ *
+ * Converts between BMAD format documents and APS plans.
+ */
+export declare class BMADFormatAdapter extends BaseFormatAdapter {
+    readonly metadata: AdapterMetadata;
+    /**
+     * Detect if content is BMAD format
+     *
+     * Uses confidence scoring based on multiple indicators:
+     * - YAML front-matter (30 points)
+     * - Requirement identifiers FR/NFR/US (25 points)
+     * - User story format (20 points)
+     * - Change log table (15 points)
+     * - Document title (10 points)
+     *
+     * @param content - Document content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content: string): DetectionResult;
+    /**
+     * Detect with file path hints for improved accuracy
+     *
+     * Uses folder structure (e.g., `_bmad/`, `.bmad/`, `_config/`)
+     * to boost detection confidence.
+     *
+     * @param content - Document content to analyze
+     * @param hint - Path and directory information
+     * @returns Detection result with confidence score
+     */
+    detectWithPath(content: string, hint: PathDetectionHint): DetectionResult;
+    /**
+     * Parse BMAD content to APS plan
+     *
+     * @param content - BMAD markdown content
+     * @param context - Parse context for provenance
+     * @param options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    parse(content: string, context?: ParseContext, _options?: AdapterOptions): Promise<ParseResult>;
+    /**
+     * Serialize APS plan to BMAD format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Adapter options
+     * @returns Serialize result with BMAD markdown
+     */
+    serialize(plan: APSPlan, _options?: AdapterOptions): Promise<SerializeResult>;
+    /**
+     * Validate BMAD content
+     *
+     * Checks for required BMAD elements without full conversion.
+     *
+     * @param content - BMAD content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    validate(content: string, _options?: AdapterOptions): Promise<ValidationResult>;
+}
+/**
+ * Create a new BMAD format adapter instance
+ *
+ * @param options - Adapter options
+ * @returns BMAD adapter instance
+ */
+export declare function createBMADAdapter(options?: AdapterOptions): BMADFormatAdapter;
+//# sourceMappingURL=format-adapter.d.ts.map

package/dist/bmad/format-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-adapter.d.ts","sourceRoot":"","sources":["../../src/bmad/format-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAgB,KAAK,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC1F,OAAO,EACL,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAa1B;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;IACtD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAOhC;IAEF;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;IASxC;;;;;;;;;OASG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,eAAe;IAQzE;;;;;;;OAOG;IACG,KAAK,CACT,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,WAAW,CAAC;IAuBvB;;;;;;OAMG;IACG,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAenF;;;;;;;;OAQG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAiEtF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,iBAAiB,CAE7E"}

package/dist/bmad/format-adapter.js

@@ -0,0 +1,186 @@
+/**
+ * BMAD Format Adapter
+ *
+ * FormatAdapter implementation for BMAD (Breakthrough Method for Agile AI-Driven Development) format.
+ * Handles PRD, Architecture, Epic, Story, and Agent documents.
+ */
+import { generateHash } from '@eddacraft/anvil-core';
+import { BaseFormatAdapter, } from '../base/types.js';
+import { createDetection } from '../base/utils.js';
+import { analyzeContent, calculateConfidenceScore, buildDetectionReason, extractFrontMatter, identifyDocumentType, } from './utils.js';
+import { BMADDocumentType } from './types.js';
+import { parseBMAD } from './parser.js';
+import { serializeToBMAD } from './serializer.js';
+/**
+ * BMAD FormatAdapter implementation
+ *
+ * Converts between BMAD format documents and APS plans.
+ */
+export class BMADFormatAdapter extends BaseFormatAdapter {
+    metadata = {
+        name: 'bmad',
+        version: '1.0.0',
+        displayName: 'BMAD (Breakthrough Method for Agile AI-Driven Development)',
+        description: 'BMAD PRD and architecture document adapter',
+        formats: ['bmad', 'prd', 'architecture'],
+        extensions: ['.md'],
+    };
+    /**
+     * Detect if content is BMAD format
+     *
+     * Uses confidence scoring based on multiple indicators:
+     * - YAML front-matter (30 points)
+     * - Requirement identifiers FR/NFR/US (25 points)
+     * - User story format (20 points)
+     * - Change log table (15 points)
+     * - Document title (10 points)
+     *
+     * @param content - Document content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content) {
+        const indicators = analyzeContent(content);
+        const confidence = calculateConfidenceScore(indicators);
+        const reason = buildDetectionReason(indicators);
+        // Detection threshold: 50% confidence
+        return createDetection(confidence >= 50, confidence, reason);
+    }
+    /**
+     * Detect with file path hints for improved accuracy
+     *
+     * Uses folder structure (e.g., `_bmad/`, `.bmad/`, `_config/`)
+     * to boost detection confidence.
+     *
+     * @param content - Document content to analyze
+     * @param hint - Path and directory information
+     * @returns Detection result with confidence score
+     */
+    detectWithPath(content, hint) {
+        const indicators = analyzeContent(content, hint);
+        const confidence = calculateConfidenceScore(indicators);
+        const reason = buildDetectionReason(indicators);
+        return createDetection(confidence >= 50, confidence, reason);
+    }
+    /**
+     * Parse BMAD content to APS plan
+     *
+     * @param content - BMAD markdown content
+     * @param context - Parse context for provenance
+     * @param options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    async parse(content, context, _options) {
+        try {
+            // Parse content to APS plan
+            const plan = parseBMAD(content, context);
+            // Generate hash for the plan
+            const planWithHash = {
+                ...plan,
+                hash: generateHash(plan),
+            };
+            return this.createParseSuccess(planWithHash);
+        }
+        catch (error) {
+            return this.createParseError([
+                {
+                    code: 'PARSE_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to parse BMAD content',
+                    details: error,
+                },
+            ]);
+        }
+    }
+    /**
+     * Serialize APS plan to BMAD format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Adapter options
+     * @returns Serialize result with BMAD markdown
+     */
+    async serialize(plan, _options) {
+        try {
+            const content = serializeToBMAD(plan);
+            return this.createSerializeSuccess(content);
+        }
+        catch (error) {
+            return this.createSerializeError([
+                {
+                    code: 'SERIALIZE_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to serialize to BMAD format',
+                    details: error,
+                },
+            ]);
+        }
+    }
+    /**
+     * Validate BMAD content
+     *
+     * Checks for required BMAD elements without full conversion.
+     *
+     * @param content - BMAD content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    async validate(content, _options) {
+        const issues = [];
+        // Check for minimum content length
+        if (content.trim().length < 100) {
+            issues.push({
+                code: 'CONTENT_TOO_SHORT',
+                path: 'content',
+                message: 'Content is too short to be a valid BMAD document',
+                severity: 'error',
+            });
+        }
+        // Analyze content for BMAD indicators
+        const indicators = analyzeContent(content);
+        const confidence = calculateConfidenceScore(indicators);
+        // Low confidence suggests invalid BMAD format
+        if (confidence < 50) {
+            issues.push({
+                code: 'LOW_CONFIDENCE',
+                path: 'content',
+                message: `Content does not appear to be a valid BMAD document (confidence: ${confidence}%)`,
+                severity: 'error',
+            });
+        }
+        // Check for at least some requirements or stories
+        if (indicators.requirementCount === 0) {
+            issues.push({
+                code: 'NO_REQUIREMENTS',
+                path: 'content',
+                message: 'No requirements (FR/NFR/US) found in document',
+                severity: 'warning',
+            });
+        }
+        // v6: Warn on agent docs missing hasSidecar
+        const frontMatter = extractFrontMatter(content);
+        const docType = identifyDocumentType(content, frontMatter);
+        if (docType === BMADDocumentType.AGENT && frontMatter?.hasSidecar === undefined) {
+            issues.push({
+                code: 'MISSING_HAS_SIDECAR',
+                path: 'frontMatter.hasSidecar',
+                message: 'Agent document is missing the hasSidecar field (expected for BMAD v6)',
+                severity: 'warning',
+            });
+        }
+        return {
+            valid: issues.filter((i) => i.severity === 'error').length === 0,
+            issues: issues.length > 0 ? issues : undefined,
+            summary: issues.filter((i) => i.severity === 'error').length === 0 && issues.length === 0
+                ? 'BMAD document is valid'
+                : issues.filter((i) => i.severity === 'error').length === 0
+                    ? `Valid with ${issues.length} warning${issues.length > 1 ? 's' : ''}`
+                    : `Found ${issues.filter((i) => i.severity === 'error').length} error${issues.filter((i) => i.severity === 'error').length > 1 ? 's' : ''}`,
+        };
+    }
+}
+/**
+ * Create a new BMAD format adapter instance
+ *
+ * @param options - Adapter options
+ * @returns BMAD adapter instance
+ */
+export function createBMADAdapter(options) {
+    return new BMADFormatAdapter(options);
+}

package/dist/bmad/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * BMAD Adapter Module
+ *
+ * Export all BMAD adapter functionality.
+ */
+export { BMADFormatAdapter, createBMADAdapter } from './format-adapter.js';
+export { BMAD_FOLDERS } from './types.js';
+export type { BMADDocument, BMADDocumentType, BMADRequirement, BMADUserStory, BMADFrontMatter, BMADChangeLogEntry, RequirementType, DetectionIndicators, } from './types.js';
+export { parseBMAD, parseBMADDocument, bmadToAPS } from './parser.js';
+export { serializeToBMAD } from './serializer.js';
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/bmad/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bmad/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,cAAc,YAAY,CAAC"}

package/dist/bmad/index.js

@@ -0,0 +1,10 @@
+/**
+ * BMAD Adapter Module
+ *
+ * Export all BMAD adapter functionality.
+ */
+export { BMADFormatAdapter, createBMADAdapter } from './format-adapter.js';
+export { BMAD_FOLDERS } from './types.js';
+export { parseBMAD, parseBMADDocument, bmadToAPS } from './parser.js';
+export { serializeToBMAD } from './serializer.js';
+export * from './utils.js';

package/dist/bmad/parser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * BMAD Parser
+ *
+ * Parses BMAD format documents (PRD, Architecture, Epics, Stories) into APS plans.
+ */
+import { type APSPlan } from '@eddacraft/anvil-core';
+import type { ParseContext } from '../base/types.js';
+import { BMADDocument } from './types.js';
+export declare function parseBMADDocument(content: string): BMADDocument;
+export declare function bmadToAPS(document: BMADDocument, context?: ParseContext, originalContent?: string): APSPlan;
+export declare function parseBMAD(content: string, context?: ParseContext): APSPlan;
+//# sourceMappingURL=parser.d.ts.map

package/dist/bmad/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/bmad/parser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAqC,MAAM,uBAAuB,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,EAAgC,MAAM,kBAAkB,CAAC;AACnF,OAAO,EAAE,YAAY,EAAmD,MAAM,YAAY,CAAC;AAiC3F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CAuB/D;AAoED,wBAAgB,SAAS,CACvB,QAAQ,EAAE,YAAY,EACtB,OAAO,CAAC,EAAE,YAAY,EACtB,eAAe,CAAC,EAAE,MAAM,GACvB,OAAO,CAkFT;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAG1E"}