@lumenflow/core 1.0.0

package/dist/compliance-parser.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Compliance Parser
+ *
+ * Parses markdown compliance documentation into structured data.
+ * Used by compliance-snapshot.mjs tool to create snapshots.
+ *
+ * @module tools/lib/compliance-parser
+ */
+/** @typedef {'ISO27001' | 'NHS_DTAC' | 'NHS_DSPT' | 'GDPR' | 'FDA'} ComplianceFramework */
+/** @typedef {'not_started' | 'in_progress' | 'completed' | 'blocked'} GapStatus */
+/** @typedef {'critical' | 'high' | 'medium' | 'low'} GapPriority */
+/** @typedef {'exists' | 'partial' | 'missing'} EvidenceStatus */
+/** @typedef {'phase_1_critical_blockers' | 'phase_2_nhs_procurement_ready' | 'phase_3_enterprise_ready'} CompliancePhase */
+/**
+ * @typedef {Object} ActionItem
+ * @property {string} id
+ * @property {string} description
+ * @property {string} owner
+ * @property {string|null} dueDate
+ * @property {GapStatus} status
+ */
+/**
+ * @typedef {Object} GapItem
+ * @property {string} gapId
+ * @property {string} title
+ * @property {string} domain
+ * @property {GapPriority} priority
+ * @property {GapStatus} status
+ * @property {CompliancePhase} phase
+ * @property {string} owner
+ * @property {string|null} targetDate
+ * @property {ActionItem[]} actionItems
+ * @property {string[]} blockers
+ * @property {string[]} dependsOn
+ */
+/**
+ * @typedef {Object} EvidenceItem
+ * @property {string} evidenceId
+ * @property {string} section
+ * @property {string} title
+ * @property {string} requirement
+ * @property {EvidenceStatus} status
+ * @property {string|null} location
+ * @property {string[]} auditNotes
+ * @property {string[]} relatedGaps
+ */
+/**
+ * @typedef {Object} FrameworkMetrics
+ * @property {ComplianceFramework} framework
+ * @property {number} totalRequirements
+ * @property {number} evidenceExists
+ * @property {number} evidencePartial
+ * @property {number} evidenceMissing
+ * @property {number} completionPercentage
+ */
+/**
+ * @typedef {Object} PhaseMetrics
+ * @property {CompliancePhase} phase
+ * @property {number} totalGaps
+ * @property {number} notStarted
+ * @property {number} inProgress
+ * @property {number} completed
+ * @property {number} blocked
+ * @property {number} completionPercentage
+ * @property {string|null} targetDate
+ */
+export declare const COMPLIANCE_FRAMEWORKS: string[];
+export declare const GAP_STATUSES: string[];
+export declare const GAP_PRIORITIES: string[];
+export declare const EVIDENCE_STATUSES: string[];
+export declare const COMPLIANCE_PHASES: string[];
+export declare class ComplianceParser {
+    /**
+     * Parse gap-analysis.md content into structured GapItems
+     * @param {string} markdown
+     * @returns {GapItem[]}
+     */
+    parseGapAnalysis(markdown: any): any[];
+    /**
+     * Parse evidence-registry.md content into structured EvidenceItems
+     * @param {string} markdown
+     * @returns {EvidenceItem[]}
+     */
+    parseEvidenceRegistry(markdown: any): any[];
+    /**
+     * Calculate framework metrics from evidence items
+     * @param {EvidenceItem[]} evidence
+     * @returns {FrameworkMetrics[]}
+     */
+    calculateFrameworkMetrics(evidence: any): {
+        framework: string;
+        totalRequirements: any;
+        evidenceExists: any;
+        evidencePartial: any;
+        evidenceMissing: any;
+        completionPercentage: number;
+    }[];
+    /**
+     * Calculate phase metrics from gap items
+     * @param {GapItem[]} gaps
+     * @returns {PhaseMetrics[]}
+     */
+    calculatePhaseMetrics(gaps: any): {
+        phase: string;
+        totalGaps: any;
+        notStarted: any;
+        inProgress: any;
+        completed: any;
+        blocked: any;
+        completionPercentage: number;
+        targetDate: string;
+    }[];
+    /** @private */
+    _parseStatus(text: any): string;
+    /** @private */
+    _parsePriority(text: any): string;
+    /** @private */
+    _parseEvidenceStatus(text: any): string;
+    /** @private */
+    _extractGapReferences(text: any): unknown[];
+    /** @private */
+    _detectFrameworks(requirement: any): any[];
+    /** @private */
+    _finalizeGap(partial: any, phase: any): {
+        gapId: any;
+        title: any;
+        domain: any;
+        priority: any;
+        status: any;
+        phase: any;
+        owner: any;
+        targetDate: any;
+        actionItems: any;
+        blockers: any;
+        dependsOn: any;
+    };
+    /** @private */
+    _finalizeEvidence(partial: any, section: any): {
+        evidenceId: any;
+        section: any;
+        title: any;
+        requirement: any;
+        status: any;
+        location: any;
+        auditNotes: any;
+        relatedGaps: any;
+    };
+    /** @private */
+    _getPhaseTargetDate(phase: any): "Month 3" | "Month 6" | "Month 12";
+}

package/dist/compliance-parser.js

@@ -0,0 +1,507 @@
+/**
+ * Compliance Parser
+ *
+ * Parses markdown compliance documentation into structured data.
+ * Used by compliance-snapshot.mjs tool to create snapshots.
+ *
+ * @module tools/lib/compliance-parser
+ */
+/** @typedef {'ISO27001' | 'NHS_DTAC' | 'NHS_DSPT' | 'GDPR' | 'FDA'} ComplianceFramework */
+/** @typedef {'not_started' | 'in_progress' | 'completed' | 'blocked'} GapStatus */
+/** @typedef {'critical' | 'high' | 'medium' | 'low'} GapPriority */
+/** @typedef {'exists' | 'partial' | 'missing'} EvidenceStatus */
+/** @typedef {'phase_1_critical_blockers' | 'phase_2_nhs_procurement_ready' | 'phase_3_enterprise_ready'} CompliancePhase */
+/**
+ * @typedef {Object} ActionItem
+ * @property {string} id
+ * @property {string} description
+ * @property {string} owner
+ * @property {string|null} dueDate
+ * @property {GapStatus} status
+ */
+/**
+ * @typedef {Object} GapItem
+ * @property {string} gapId
+ * @property {string} title
+ * @property {string} domain
+ * @property {GapPriority} priority
+ * @property {GapStatus} status
+ * @property {CompliancePhase} phase
+ * @property {string} owner
+ * @property {string|null} targetDate
+ * @property {ActionItem[]} actionItems
+ * @property {string[]} blockers
+ * @property {string[]} dependsOn
+ */
+/**
+ * @typedef {Object} EvidenceItem
+ * @property {string} evidenceId
+ * @property {string} section
+ * @property {string} title
+ * @property {string} requirement
+ * @property {EvidenceStatus} status
+ * @property {string|null} location
+ * @property {string[]} auditNotes
+ * @property {string[]} relatedGaps
+ */
+/**
+ * @typedef {Object} FrameworkMetrics
+ * @property {ComplianceFramework} framework
+ * @property {number} totalRequirements
+ * @property {number} evidenceExists
+ * @property {number} evidencePartial
+ * @property {number} evidenceMissing
+ * @property {number} completionPercentage
+ */
+/**
+ * @typedef {Object} PhaseMetrics
+ * @property {CompliancePhase} phase
+ * @property {number} totalGaps
+ * @property {number} notStarted
+ * @property {number} inProgress
+ * @property {number} completed
+ * @property {number} blocked
+ * @property {number} completionPercentage
+ * @property {string|null} targetDate
+ */
+export const COMPLIANCE_FRAMEWORKS = ['ISO27001', 'NHS_DTAC', 'NHS_DSPT', 'GDPR', 'FDA'];
+export const GAP_STATUSES = ['not_started', 'in_progress', 'completed', 'blocked'];
+export const GAP_PRIORITIES = ['critical', 'high', 'medium', 'low'];
+export const EVIDENCE_STATUSES = ['exists', 'partial', 'missing'];
+export const COMPLIANCE_PHASES = [
+    'phase_1_critical_blockers',
+    'phase_2_nhs_procurement_ready',
+    'phase_3_enterprise_ready',
+];
+// Status emoji mappings
+const STATUS_EMOJI_MAP = {
+    'Not Started': 'not_started',
+    'In Progress': 'in_progress',
+    Completed: 'completed',
+    Blocked: 'blocked',
+};
+const PRIORITY_EMOJI_MAP = {
+    CRITICAL: 'critical',
+    HIGH: 'high',
+    MEDIUM: 'medium',
+    LOW: 'low',
+};
+const EVIDENCE_STATUS_MAP = {
+    'Evidence exists': 'exists',
+    'Partial evidence': 'partial',
+    'No evidence': 'missing',
+};
+const PHASE_HEADER_MAP = {
+    'Phase 1': 'phase_1_critical_blockers',
+    'Phase 2': 'phase_2_nhs_procurement_ready',
+    'Phase 3': 'phase_3_enterprise_ready',
+};
+// Framework keyword mappings for evidence parsing
+const FRAMEWORK_KEYWORDS = {
+    ISO27001: ['ISO 27001', 'ISO27001', 'SOC 2', 'SOC2'],
+    NHS_DTAC: ['NHS DTAC', 'DTAC'],
+    NHS_DSPT: ['NHS DSPT', 'DSPT'],
+    GDPR: ['GDPR', 'UK GDPR', 'Data Protection'],
+    FDA: ['FDA', '21 CFR', 'Medical Device'],
+};
+export class ComplianceParser {
+    /**
+     * Parse gap-analysis.md content into structured GapItems
+     * @param {string} markdown
+     * @returns {GapItem[]}
+     */
+    parseGapAnalysis(markdown) {
+        const gaps = [];
+        const lines = markdown.split('\n');
+        let currentPhase = 'phase_1_critical_blockers';
+        let currentGap = null;
+        let inActionItems = false;
+        let inBlockers = false;
+        let currentActionItem = null;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmedLine = line.trim();
+            // Detect phase headers
+            if (trimmedLine.startsWith('## Phase')) {
+                for (const [phaseKey, phaseValue] of Object.entries(PHASE_HEADER_MAP)) {
+                    if (trimmedLine.includes(phaseKey)) {
+                        currentPhase = phaseValue;
+                        break;
+                    }
+                }
+                continue;
+            }
+            // Detect GAP header
+            const gapMatch = trimmedLine.match(/^### (GAP-\d+):\s*(.+)$/);
+            if (gapMatch) {
+                // Save previous gap if exists
+                if (currentGap?.gapId) {
+                    if (currentActionItem?.id) {
+                        currentGap.actionItems.push(currentActionItem);
+                    }
+                    gaps.push(this._finalizeGap(currentGap, currentPhase));
+                }
+                currentGap = {
+                    gapId: gapMatch[1],
+                    title: gapMatch[2],
+                    phase: currentPhase,
+                    actionItems: [],
+                    blockers: [],
+                    dependsOn: [],
+                };
+                currentActionItem = null;
+                inActionItems = false;
+                inBlockers = false;
+                continue;
+            }
+            if (!currentGap)
+                continue;
+            // Parse fields
+            if (trimmedLine.startsWith('**Priority:**')) {
+                currentGap.priority = this._parsePriority(trimmedLine);
+            }
+            else if (trimmedLine.startsWith('**Domain:**')) {
+                currentGap.domain = trimmedLine.replace('**Domain:**', '').trim();
+            }
+            else if (trimmedLine.startsWith('**Status:**')) {
+                currentGap.status = this._parseStatus(trimmedLine);
+            }
+            else if (trimmedLine.startsWith('**Owner:**')) {
+                currentGap.owner = trimmedLine.replace('**Owner:**', '').trim();
+            }
+            else if (trimmedLine.startsWith('**Target Date:**')) {
+                currentGap.targetDate = trimmedLine.replace('**Target Date:**', '').trim() || null;
+            }
+            else if (trimmedLine.startsWith('**Depends On:**')) {
+                const deps = this._extractGapReferences(trimmedLine);
+                currentGap.dependsOn = deps;
+            }
+            // Detect sections
+            if (trimmedLine === '**Action Items:**') {
+                inActionItems = true;
+                inBlockers = false;
+                continue;
+            }
+            if (trimmedLine === '**Blockers:**') {
+                inActionItems = false;
+                inBlockers = true;
+                continue;
+            }
+            if (trimmedLine.startsWith('**') && trimmedLine.endsWith('**')) {
+                if (!trimmedLine.includes('Action Items') && !trimmedLine.includes('Blockers')) {
+                    inActionItems = false;
+                    inBlockers = false;
+                }
+            }
+            // Parse action items
+            if (inActionItems) {
+                const actionMatch = trimmedLine.match(/^- \[[ x]\] \*\*(\d+\.\d+)\*\*\s+(.+)$/);
+                if (actionMatch) {
+                    if (currentActionItem?.id) {
+                        currentGap.actionItems.push(currentActionItem);
+                    }
+                    const isCompleted = trimmedLine.includes('[x]');
+                    currentActionItem = {
+                        id: actionMatch[1],
+                        description: actionMatch[2],
+                        status: isCompleted ? 'completed' : 'not_started',
+                        owner: null,
+                        dueDate: null,
+                    };
+                }
+                else if (currentActionItem && trimmedLine.startsWith('- Owner:')) {
+                    currentActionItem.owner = trimmedLine.replace('- Owner:', '').trim();
+                }
+                else if (currentActionItem && trimmedLine.startsWith('- Due:')) {
+                    currentActionItem.dueDate = trimmedLine.replace('- Due:', '').trim();
+                }
+                else if (currentActionItem && trimmedLine.startsWith('- Status:')) {
+                    currentActionItem.status = this._parseStatus(trimmedLine);
+                }
+            }
+            // Parse blockers
+            if (inBlockers && trimmedLine.startsWith('-') && !trimmedLine.includes('None')) {
+                const blockerText = trimmedLine.replace(/^-\s*/, '').replace(/^[🔴🟡]\s*/, '');
+                if (blockerText.trim()) {
+                    currentGap.blockers.push(blockerText.trim());
+                    // Also extract any GAP references
+                    const gapRefs = this._extractGapReferences(trimmedLine);
+                    for (const ref of gapRefs) {
+                        if (!currentGap.dependsOn.includes(ref)) {
+                            currentGap.dependsOn.push(ref);
+                        }
+                    }
+                }
+            }
+        }
+        // Save final gap
+        if (currentGap?.gapId) {
+            if (currentActionItem?.id) {
+                currentGap.actionItems.push(currentActionItem);
+            }
+            gaps.push(this._finalizeGap(currentGap, currentPhase));
+        }
+        return gaps;
+    }
+    /**
+     * Parse evidence-registry.md content into structured EvidenceItems
+     * @param {string} markdown
+     * @returns {EvidenceItem[]}
+     */
+    parseEvidenceRegistry(markdown) {
+        const evidence = [];
+        const lines = markdown.split('\n');
+        let currentSection = '';
+        let currentEvidence = null;
+        let inAuditNotes = false;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmedLine = line.trim();
+            // Detect section headers (## N. Section Name)
+            const sectionMatch = trimmedLine.match(/^## \d+\.\s*(.+)$/);
+            if (sectionMatch) {
+                currentSection = sectionMatch[1];
+                continue;
+            }
+            // Detect evidence item header (### N.N Title)
+            const evidenceMatch = trimmedLine.match(/^### (\d+\.\d+)\s+(.+)$/);
+            if (evidenceMatch) {
+                // Save previous evidence if exists
+                if (currentEvidence?.evidenceId) {
+                    evidence.push(this._finalizeEvidence(currentEvidence, currentSection));
+                }
+                currentEvidence = {
+                    evidenceId: evidenceMatch[1],
+                    title: evidenceMatch[2],
+                    section: currentSection,
+                    auditNotes: [],
+                    relatedGaps: [],
+                };
+                inAuditNotes = false;
+                continue;
+            }
+            if (!currentEvidence)
+                continue;
+            // Parse fields
+            if (trimmedLine.startsWith('**Requirement**:')) {
+                currentEvidence.requirement = trimmedLine.replace('**Requirement**:', '').trim();
+            }
+            else if (trimmedLine.startsWith('**Status**:')) {
+                currentEvidence.status = this._parseEvidenceStatus(trimmedLine);
+            }
+            // Detect Evidence section with Location
+            if (trimmedLine.includes('**Location**:')) {
+                const locationMatch = trimmedLine.match(/\*\*Location\*\*:\s*\[?([^\]]+)\]?/);
+                if (locationMatch) {
+                    currentEvidence.location = locationMatch[1].replace(/\(.*\)/, '').trim();
+                }
+            }
+            // Detect Audit Notes section
+            if (trimmedLine === '**Audit Notes**:') {
+                inAuditNotes = true;
+                continue;
+            }
+            // Parse audit notes
+            if (inAuditNotes && trimmedLine.startsWith('-')) {
+                const noteText = trimmedLine.replace(/^-\s*/, '').trim();
+                if (noteText) {
+                    currentEvidence.auditNotes.push(noteText);
+                    // Extract GAP references from notes
+                    const gapRefs = this._extractGapReferences(trimmedLine);
+                    for (const ref of gapRefs) {
+                        if (!currentEvidence.relatedGaps.includes(ref)) {
+                            currentEvidence.relatedGaps.push(ref);
+                        }
+                    }
+                }
+            }
+            // End audit notes on next section
+            if (inAuditNotes && trimmedLine.startsWith('---')) {
+                inAuditNotes = false;
+            }
+        }
+        // Save final evidence
+        if (currentEvidence?.evidenceId) {
+            evidence.push(this._finalizeEvidence(currentEvidence, currentSection));
+        }
+        return evidence;
+    }
+    /**
+     * Calculate framework metrics from evidence items
+     * @param {EvidenceItem[]} evidence
+     * @returns {FrameworkMetrics[]}
+     */
+    calculateFrameworkMetrics(evidence) {
+        const frameworkCounts = {};
+        // Initialize all frameworks
+        for (const framework of COMPLIANCE_FRAMEWORKS) {
+            frameworkCounts[framework] = { total: 0, exists: 0, partial: 0, missing: 0 };
+        }
+        // Count evidence per framework
+        for (const item of evidence) {
+            const frameworks = this._detectFrameworks(item.requirement);
+            for (const framework of frameworks) {
+                frameworkCounts[framework].total++;
+                if (item.status === 'exists') {
+                    frameworkCounts[framework].exists++;
+                }
+                else if (item.status === 'partial') {
+                    frameworkCounts[framework].partial++;
+                }
+                else {
+                    frameworkCounts[framework].missing++;
+                }
+            }
+        }
+        // Calculate metrics
+        return COMPLIANCE_FRAMEWORKS.map((framework) => {
+            const counts = frameworkCounts[framework];
+            // Completion: exists = 100%, partial = 50%, missing = 0%
+            const completionPercentage = counts.total > 0
+                ? Math.round((counts.exists * 100 + counts.partial * 50) / counts.total)
+                : 0;
+            return {
+                framework,
+                totalRequirements: counts.total,
+                evidenceExists: counts.exists,
+                evidencePartial: counts.partial,
+                evidenceMissing: counts.missing,
+                completionPercentage,
+            };
+        });
+    }
+    /**
+     * Calculate phase metrics from gap items
+     * @param {GapItem[]} gaps
+     * @returns {PhaseMetrics[]}
+     */
+    calculatePhaseMetrics(gaps) {
+        const phaseCounts = {};
+        // Initialize all phases
+        for (const phase of COMPLIANCE_PHASES) {
+            phaseCounts[phase] = { total: 0, notStarted: 0, inProgress: 0, completed: 0, blocked: 0 };
+        }
+        // Count gaps per phase
+        for (const gap of gaps) {
+            const phase = gap.phase;
+            phaseCounts[phase].total++;
+            switch (gap.status) {
+                case 'not_started':
+                    phaseCounts[phase].notStarted++;
+                    break;
+                case 'in_progress':
+                    phaseCounts[phase].inProgress++;
+                    break;
+                case 'completed':
+                    phaseCounts[phase].completed++;
+                    break;
+                case 'blocked':
+                    phaseCounts[phase].blocked++;
+                    break;
+            }
+        }
+        // Calculate metrics
+        return COMPLIANCE_PHASES.map((phase) => {
+            const counts = phaseCounts[phase];
+            const completionPercentage = counts.total > 0 ? Math.round((counts.completed / counts.total) * 100 * 100) / 100 : 0;
+            return {
+                phase,
+                totalGaps: counts.total,
+                notStarted: counts.notStarted,
+                inProgress: counts.inProgress,
+                completed: counts.completed,
+                blocked: counts.blocked,
+                completionPercentage,
+                targetDate: this._getPhaseTargetDate(phase),
+            };
+        });
+    }
+    // Helper methods
+    /** @private */
+    _parseStatus(text) {
+        for (const [key, value] of Object.entries(STATUS_EMOJI_MAP)) {
+            if (text.includes(key)) {
+                return value;
+            }
+        }
+        return 'not_started';
+    }
+    /** @private */
+    _parsePriority(text) {
+        for (const [key, value] of Object.entries(PRIORITY_EMOJI_MAP)) {
+            if (text.toUpperCase().includes(key)) {
+                return value;
+            }
+        }
+        return 'medium';
+    }
+    /** @private */
+    _parseEvidenceStatus(text) {
+        for (const [key, value] of Object.entries(EVIDENCE_STATUS_MAP)) {
+            if (text.includes(key)) {
+                return value;
+            }
+        }
+        return 'missing';
+    }
+    /** @private */
+    _extractGapReferences(text) {
+        const matches = text.match(/GAP-\d+/g);
+        return matches ? [...new Set(matches)] : [];
+    }
+    /** @private */
+    _detectFrameworks(requirement) {
+        const frameworks = [];
+        for (const [framework, keywords] of Object.entries(FRAMEWORK_KEYWORDS)) {
+            for (const keyword of keywords) {
+                if (requirement.includes(keyword)) {
+                    frameworks.push(framework);
+                    break;
+                }
+            }
+        }
+        return frameworks;
+    }
+    /** @private */
+    _finalizeGap(partial, phase) {
+        return {
+            gapId: partial.gapId || 'UNKNOWN',
+            title: partial.title || 'Untitled',
+            domain: partial.domain || 'Unknown',
+            priority: partial.priority || 'medium',
+            status: partial.status || 'not_started',
+            phase: partial.phase || phase,
+            owner: partial.owner || 'Unassigned',
+            targetDate: partial.targetDate || null,
+            actionItems: partial.actionItems || [],
+            blockers: partial.blockers || [],
+            dependsOn: partial.dependsOn || [],
+        };
+    }
+    /** @private */
+    _finalizeEvidence(partial, section) {
+        return {
+            evidenceId: partial.evidenceId || 'UNKNOWN',
+            section: partial.section || section,
+            title: partial.title || 'Untitled',
+            requirement: partial.requirement || '',
+            status: partial.status || 'missing',
+            location: partial.location || null,
+            auditNotes: partial.auditNotes || [],
+            relatedGaps: partial.relatedGaps || [],
+        };
+    }
+    /** @private */
+    _getPhaseTargetDate(phase) {
+        switch (phase) {
+            case 'phase_1_critical_blockers':
+                return 'Month 3';
+            case 'phase_2_nhs_procurement_ready':
+                return 'Month 6';
+            case 'phase_3_enterprise_ready':
+                return 'Month 12';
+            default:
+                return null;
+        }
+    }
+}

package/dist/constants/backlog-patterns.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Backlog Parsing Patterns
+ *
+ * Centralizes patterns for parsing status.md and backlog.md files.
+ * Used by lane-checker.mjs and related backlog utilities.
+ */
+/** Markdown section header patterns for In Progress section */
+export declare const IN_PROGRESS_HEADERS: string[];
+/**
+ * Pattern for extracting WU ID from backlog links.
+ * Matches: [WU-123 — Title text](path/to/file.yaml)
+ * Captures: WU ID (e.g., "WU-123")
+ */
+export declare const WU_LINK_PATTERN: RegExp;
+/**
+ * Check if a line matches an In Progress section header.
+ * @param {string} line - Line to check (will be trimmed and lowercased)
+ * @returns {boolean} True if line is an In Progress header
+ */
+export declare function isInProgressHeader(line: any): boolean;

package/dist/constants/backlog-patterns.js

@@ -0,0 +1,23 @@
+/**
+ * Backlog Parsing Patterns
+ *
+ * Centralizes patterns for parsing status.md and backlog.md files.
+ * Used by lane-checker.mjs and related backlog utilities.
+ */
+/** Markdown section header patterns for In Progress section */
+export const IN_PROGRESS_HEADERS = ['## in progress', '## 🔧 in progress'];
+/**
+ * Pattern for extracting WU ID from backlog links.
+ * Matches: [WU-123 — Title text](path/to/file.yaml)
+ * Captures: WU ID (e.g., "WU-123")
+ */
+export const WU_LINK_PATTERN = /\[([A-Z]+-\d+)\s*—\s*[^\]]+\]\([^)]+\)/gi;
+/**
+ * Check if a line matches an In Progress section header.
+ * @param {string} line - Line to check (will be trimmed and lowercased)
+ * @returns {boolean} True if line is an In Progress header
+ */
+export function isInProgressHeader(line) {
+    const normalized = line.trim().toLowerCase();
+    return IN_PROGRESS_HEADERS.some((header) => normalized === header || normalized.startsWith(header));
+}