agentic-qe 3.7.16 → 3.7.18

package/dist/cli/commands/coverage.js

@@ -222,6 +222,56 @@ export function createCoverageCommand(context, cleanupAndExit, ensureInitialized
             await cleanupAndExit(1);
         }
     });
+    // Subcommand: coverage gaps — enumerate unhandled branches via static analysis
+    coverageCmd
+        .command('gaps')
+        .description('Enumerate unhandled branches in source files')
+        .argument('<file>', 'Source file to analyze')
+        .option('--mechanical', 'Exhaustive mode: report all branches without filtering')
+        .option('--json', 'Output as JSON')
+        .option('--markdown', 'Output as markdown report')
+        .action(async (file, options) => {
+        try {
+            const { readFileSync, existsSync } = await import('fs');
+            const pathMod = await import('path');
+            const { enumerateBranches, formatBranchReport, formatBranchJSON } = await import('../../analysis/branch-enumerator.js');
+            const resolvedFile = pathMod.resolve(file);
+            if (!existsSync(resolvedFile)) {
+                console.error(chalk.red(`\n  File not found: ${resolvedFile}\n`));
+                await cleanupAndExit(1);
+            }
+            const sourceCode = readFileSync(resolvedFile, 'utf-8');
+            const result = enumerateBranches(sourceCode, resolvedFile);
+            if (options.json) {
+                console.log(formatBranchJSON(result));
+            }
+            else if (options.markdown) {
+                console.log(formatBranchReport(result));
+            }
+            else {
+                // Table format
+                console.log(`\n${chalk.cyan('Branch Enumeration:')} ${chalk.white(file)}`);
+                console.log(chalk.gray(`Found ${result.unhandledCount} unhandled branches (${result.duration}ms)\n`));
+                if (result.branches.length > 0) {
+                    console.log(chalk.dim('Line | Severity | Construct                 | Trigger'));
+                    console.log(chalk.dim('-----|----------|---------------------------|--------'));
+                    for (const b of result.branches) {
+                        const severityColor = b.severity === 'high' ? chalk.red : b.severity === 'medium' ? chalk.yellow : chalk.gray;
+                        console.log(`${String(b.line).padStart(4)} | ${severityColor(b.severity.padEnd(8))} | ${b.construct.padEnd(25)} | ${b.triggerCondition}`);
+                    }
+                }
+                else {
+                    console.log(chalk.green('No unhandled branches detected.'));
+                }
+                console.log('');
+            }
+            await cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error(chalk.red('\nBranch enumeration failed:'), error);
+            await cleanupAndExit(1);
+        }
+    });
     return coverageCmd;
 }
 //# sourceMappingURL=coverage.js.map

package/dist/context/compiler.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Context Compiler (BMAD-005)
+ *
+ * Aggregates relevant context from multiple sources before agent execution.
+ * Produces a focused context document that reduces redundant queries.
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './sources/types.js';
+export interface CompiledContext {
+    /** One-paragraph overview */
+    summary: string;
+    /** Aggregated fragments sorted by priority */
+    fragments: ContextFragment[];
+    /** Total estimated tokens */
+    totalTokens: number;
+    /** Which sources contributed */
+    sources: string[];
+    /** Compilation timestamp */
+    timestamp: string;
+    /** Compilation duration in ms */
+    duration: number;
+}
+export interface CompilerConfig {
+    /** Maximum total token budget (default: 8000, using chars/3.5 estimation per Gap 7) */
+    maxTokenBudget?: number;
+    /** Sources to use (default: all) */
+    sources?: ContextSource[];
+    /** Cache TTL in ms (default: 5 minutes) */
+    cacheTtlMs?: number;
+}
+/**
+ * Create default context sources.
+ */
+export declare function createDefaultSources(): ContextSource[];
+export declare class ContextCompiler {
+    private sources;
+    private maxTokenBudget;
+    private cache;
+    private cacheTtl;
+    constructor(config?: CompilerConfig);
+    /**
+     * Compile context for a request.
+     */
+    compile(request: ContextRequest): Promise<CompiledContext>;
+    /**
+     * Clear the cache.
+     */
+    clearCache(): void;
+    /**
+     * Get cache stats.
+     */
+    getCacheStats(): {
+        size: number;
+        ttlMs: number;
+    };
+    private buildCacheKey;
+    private generateSummary;
+}
+/**
+ * Format compiled context as a string for agent prompts.
+ */
+export declare function formatContextForPrompt(context: CompiledContext): string;
+//# sourceMappingURL=compiler.d.ts.map

package/dist/context/compiler.js

@@ -0,0 +1,143 @@
+/**
+ * Context Compiler (BMAD-005)
+ *
+ * Aggregates relevant context from multiple sources before agent execution.
+ * Produces a focused context document that reduces redundant queries.
+ */
+import { MemoryContextSource } from './sources/memory-source.js';
+import { GitContextSource } from './sources/git-source.js';
+import { TestContextSource } from './sources/test-source.js';
+import { CoverageContextSource } from './sources/coverage-source.js';
+const DEFAULT_TOKEN_BUDGET = 8000;
+const DEFAULT_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+/**
+ * Create default context sources.
+ */
+export function createDefaultSources() {
+    return [
+        new MemoryContextSource(),
+        new TestContextSource(),
+        new GitContextSource(),
+        new CoverageContextSource(),
+    ];
+}
+export class ContextCompiler {
+    sources;
+    maxTokenBudget;
+    cache = new Map();
+    cacheTtl;
+    constructor(config) {
+        this.sources = config?.sources || createDefaultSources();
+        this.maxTokenBudget = config?.maxTokenBudget || DEFAULT_TOKEN_BUDGET;
+        this.cacheTtl = config?.cacheTtlMs || DEFAULT_CACHE_TTL;
+    }
+    /**
+     * Compile context for a request.
+     */
+    async compile(request) {
+        const start = Date.now();
+        // Check cache
+        const cacheKey = this.buildCacheKey(request);
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.cacheTtl) {
+            return cached.result;
+        }
+        // Override budget if request specifies
+        const budget = request.maxTokenBudget || this.maxTokenBudget;
+        // Gather from all sources in parallel
+        const sourceResults = await Promise.allSettled(this.sources.map(async (source) => {
+            try {
+                const fragments = await source.gather(request);
+                return { sourceId: source.id, sourceName: source.name, priority: source.priority, fragments };
+            }
+            catch {
+                return { sourceId: source.id, sourceName: source.name, priority: source.priority, fragments: [] };
+            }
+        }));
+        // Collect all fragments with source priority
+        const allFragments = [];
+        const contributingSources = [];
+        for (const result of sourceResults) {
+            if (result.status === 'fulfilled') {
+                const { sourceId, priority, fragments } = result.value;
+                if (fragments.length > 0) {
+                    contributingSources.push(sourceId);
+                    for (const fragment of fragments) {
+                        allFragments.push({ ...fragment, sourcePriority: priority });
+                    }
+                }
+            }
+        }
+        // Sort by priority (highest first), then by relevance
+        allFragments.sort((a, b) => {
+            if (a.sourcePriority !== b.sourcePriority)
+                return b.sourcePriority - a.sourcePriority;
+            return b.relevance - a.relevance;
+        });
+        // Trim to fit budget
+        const selectedFragments = [];
+        let usedTokens = 0;
+        for (const fragment of allFragments) {
+            if (usedTokens + fragment.estimatedTokens <= budget) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { sourcePriority: _sp, ...frag } = fragment;
+                selectedFragments.push(frag);
+                usedTokens += fragment.estimatedTokens;
+            }
+        }
+        // Generate summary
+        const summary = this.generateSummary(request, selectedFragments, contributingSources);
+        const compiled = {
+            summary,
+            fragments: selectedFragments,
+            totalTokens: usedTokens,
+            sources: contributingSources,
+            timestamp: new Date().toISOString(),
+            duration: Date.now() - start,
+        };
+        // Cache result
+        this.cache.set(cacheKey, { result: compiled, timestamp: Date.now() });
+        return compiled;
+    }
+    /**
+     * Clear the cache.
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache stats.
+     */
+    getCacheStats() {
+        return { size: this.cache.size, ttlMs: this.cacheTtl };
+    }
+    buildCacheKey(request) {
+        return `${request.agentType}:${request.targetFiles.sort().join(',')}:${request.taskDescription.slice(0, 100)}`;
+    }
+    generateSummary(request, fragments, sources) {
+        return [
+            `Context compiled for ${request.agentType} agent.`,
+            `Target: ${request.targetFiles.length} file(s).`,
+            `Sources: ${sources.join(', ')}.`,
+            `Fragments: ${fragments.length} (${fragments.reduce((s, f) => s + f.estimatedTokens, 0)} est. tokens).`,
+        ].join(' ');
+    }
+}
+/**
+ * Format compiled context as a string for agent prompts.
+ */
+export function formatContextForPrompt(context) {
+    const lines = [];
+    lines.push('## Compiled Context');
+    lines.push('');
+    lines.push(context.summary);
+    lines.push('');
+    for (const fragment of context.fragments) {
+        lines.push(`### ${fragment.title}`);
+        lines.push(fragment.content);
+        lines.push('');
+    }
+    lines.push(`_Context compiled: ${context.timestamp} (${context.duration}ms)_`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=compiler.js.map

package/dist/context/index.d.ts

@@ -0,0 +1,8 @@
+export { ContextCompiler, formatContextForPrompt, createDefaultSources } from './compiler.js';
+export type { CompiledContext, CompilerConfig } from './compiler.js';
+export type { ContextSource, ContextRequest, ContextFragment } from './sources/types.js';
+export { MemoryContextSource } from './sources/memory-source.js';
+export { GitContextSource } from './sources/git-source.js';
+export { TestContextSource } from './sources/test-source.js';
+export { CoverageContextSource } from './sources/coverage-source.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/context/index.js

@@ -0,0 +1,6 @@
+export { ContextCompiler, formatContextForPrompt, createDefaultSources } from './compiler.js';
+export { MemoryContextSource } from './sources/memory-source.js';
+export { GitContextSource } from './sources/git-source.js';
+export { TestContextSource } from './sources/test-source.js';
+export { CoverageContextSource } from './sources/coverage-source.js';
+//# sourceMappingURL=index.js.map

package/dist/context/sources/coverage-source.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Coverage Source - Coverage data for target files
+ *
+ * Reads coverage reports from standard locations (Istanbul/NYC output)
+ * and extracts per-file and project-level coverage metrics.
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export declare class CoverageContextSource implements ContextSource {
+    id: string;
+    name: string;
+    priority: number;
+    maxTokens: number;
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+}
+//# sourceMappingURL=coverage-source.d.ts.map

package/dist/context/sources/coverage-source.js

@@ -0,0 +1,77 @@
+/**
+ * Coverage Source - Coverage data for target files
+ *
+ * Reads coverage reports from standard locations (Istanbul/NYC output)
+ * and extracts per-file and project-level coverage metrics.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+export class CoverageContextSource {
+    id = 'coverage';
+    name = 'Coverage Data';
+    priority = 50;
+    maxTokens = 1000;
+    async gather(request) {
+        const fragments = [];
+        // Look for coverage reports in standard locations
+        const coveragePaths = [
+            join(process.cwd(), 'coverage', 'coverage-summary.json'),
+            join(process.cwd(), 'coverage', 'coverage-final.json'),
+            join(process.cwd(), '.coverage', 'coverage-summary.json'),
+        ];
+        for (const coveragePath of coveragePaths) {
+            if (!existsSync(coveragePath))
+                continue;
+            try {
+                const raw = readFileSync(coveragePath, 'utf-8');
+                const data = JSON.parse(raw);
+                // Extract coverage for target files
+                const targetCoverage = [];
+                for (const targetFile of request.targetFiles) {
+                    const fileName = basename(targetFile);
+                    // Search for matching entries in coverage data
+                    for (const [filePath, metrics] of Object.entries(data)) {
+                        if (filePath.includes(fileName) && metrics && typeof metrics === 'object') {
+                            const m = metrics;
+                            const lines = m.lines?.pct ?? m.statements?.pct;
+                            const branches = m.branches?.pct;
+                            const functions = m.functions?.pct;
+                            if (lines !== undefined) {
+                                targetCoverage.push(`${fileName}: lines=${lines}%${branches !== undefined ? `, branches=${branches}%` : ''}${functions !== undefined ? `, functions=${functions}%` : ''}`);
+                            }
+                        }
+                    }
+                }
+                if (targetCoverage.length > 0) {
+                    const content = `Coverage for target files:\n${targetCoverage.join('\n')}`;
+                    fragments.push({
+                        sourceId: this.id,
+                        title: 'File Coverage Data',
+                        content,
+                        estimatedTokens: Math.ceil(content.length / 3.5),
+                        relevance: 0.6,
+                    });
+                }
+                // Also extract overall project coverage if available
+                if (data.total && typeof data.total === 'object') {
+                    const total = data.total;
+                    const content = `Project coverage: lines=${total.lines?.pct ?? '?'}%, branches=${total.branches?.pct ?? '?'}%, functions=${total.functions?.pct ?? '?'}%`;
+                    fragments.push({
+                        sourceId: this.id,
+                        title: 'Project Coverage Summary',
+                        content,
+                        estimatedTokens: Math.ceil(content.length / 3.5),
+                        relevance: 0.4,
+                    });
+                }
+                break; // Found a coverage file, stop looking
+            }
+            catch {
+                // Failed to parse coverage file
+                continue;
+            }
+        }
+        return fragments;
+    }
+}
+//# sourceMappingURL=coverage-source.js.map

package/dist/context/sources/git-source.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Git Source - Recent commit context for target files
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export declare class GitContextSource implements ContextSource {
+    id: string;
+    name: string;
+    priority: number;
+    maxTokens: number;
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+}
+//# sourceMappingURL=git-source.d.ts.map

package/dist/context/sources/git-source.js

@@ -0,0 +1,33 @@
+/**
+ * Git Source - Recent commit context for target files
+ */
+import { execSync } from 'child_process';
+export class GitContextSource {
+    id = 'git';
+    name = 'Git History';
+    priority = 60;
+    maxTokens = 1500;
+    async gather(request) {
+        const fragments = [];
+        for (const file of request.targetFiles.slice(0, 5)) { // Cap at 5 files
+            try {
+                const log = execSync(`git log --oneline -5 -- "${file}" 2>/dev/null || true`, { encoding: 'utf-8', timeout: 5000 }).trim();
+                if (log) {
+                    const content = `Recent commits for ${file}:\n${log}`;
+                    fragments.push({
+                        sourceId: this.id,
+                        title: `Git history: ${file}`,
+                        content,
+                        estimatedTokens: Math.ceil(content.length / 3.5),
+                        relevance: 0.5,
+                    });
+                }
+            }
+            catch {
+                // Git command failed — skip this file
+            }
+        }
+        return fragments;
+    }
+}
+//# sourceMappingURL=git-source.js.map

package/dist/context/sources/index.d.ts

@@ -0,0 +1,6 @@
+export type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export { MemoryContextSource } from './memory-source.js';
+export { GitContextSource } from './git-source.js';
+export { TestContextSource } from './test-source.js';
+export { CoverageContextSource } from './coverage-source.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/context/sources/index.js

@@ -0,0 +1,5 @@
+export { MemoryContextSource } from './memory-source.js';
+export { GitContextSource } from './git-source.js';
+export { TestContextSource } from './test-source.js';
+export { CoverageContextSource } from './coverage-source.js';
+//# sourceMappingURL=index.js.map

package/dist/context/sources/memory-source.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Memory Source - Relevant patterns from learning database
+ *
+ * Queries the SQLite pattern store for patterns relevant to the current task.
+ * Falls back to basic task context when the database is unavailable.
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export declare class MemoryContextSource implements ContextSource {
+    id: string;
+    name: string;
+    priority: number;
+    maxTokens: number;
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+    private fallbackGather;
+    private extractDomainKeywords;
+}
+//# sourceMappingURL=memory-source.d.ts.map

package/dist/context/sources/memory-source.js

@@ -0,0 +1,94 @@
+/**
+ * Memory Source - Relevant patterns from learning database
+ *
+ * Queries the SQLite pattern store for patterns relevant to the current task.
+ * Falls back to basic task context when the database is unavailable.
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+export class MemoryContextSource {
+    id = 'memory';
+    name = 'Pattern Memory';
+    priority = 80;
+    maxTokens = 2000;
+    async gather(request) {
+        const fragments = [];
+        // Try to query the learning database for relevant patterns
+        try {
+            const dbPath = join(process.cwd(), '.agentic-qe', 'memory.db');
+            if (!existsSync(dbPath)) {
+                return this.fallbackGather(request);
+            }
+            // Dynamic import to avoid hard dependency
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(dbPath, { readonly: true });
+            try {
+                // Query patterns relevant to the task domain
+                const domainKeywords = this.extractDomainKeywords(request.taskDescription);
+                if (domainKeywords.length > 0) {
+                    const placeholders = domainKeywords.map(() => 'domain LIKE ?').join(' OR ');
+                    const likePatterns = domainKeywords.map(k => `%${k}%`);
+                    const stmt = db.prepare(`SELECT name, domain, description, confidence
+             FROM qe_patterns
+             WHERE ${placeholders}
+             ORDER BY confidence DESC
+             LIMIT 10`);
+                    const patterns = stmt.all(...likePatterns);
+                    if (patterns.length > 0) {
+                        const content = patterns.map(p => `- **${p.name}** (${p.domain}, confidence: ${(p.confidence * 100).toFixed(0)}%): ${p.description || 'No description'}`).join('\n');
+                        fragments.push({
+                            sourceId: this.id,
+                            title: 'Relevant Patterns from Learning Database',
+                            content: `Found ${patterns.length} relevant patterns:\n\n${content}`,
+                            estimatedTokens: Math.ceil(content.length / 3.5),
+                            relevance: 0.8,
+                        });
+                    }
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Database access failed -- use fallback
+            return this.fallbackGather(request);
+        }
+        if (fragments.length === 0) {
+            return this.fallbackGather(request);
+        }
+        return fragments;
+    }
+    fallbackGather(request) {
+        const content = [
+            `Task: ${request.taskDescription}`,
+            `Agent: ${request.agentType}`,
+            `Files: ${request.targetFiles.join(', ')}`,
+        ].join('\n');
+        return [{
+                sourceId: this.id,
+                title: 'Task Context',
+                content,
+                estimatedTokens: Math.ceil(content.length / 3.5),
+                relevance: 0.5,
+            }];
+    }
+    extractDomainKeywords(description) {
+        const keywords = [];
+        const desc = description.toLowerCase();
+        const domainMap = {
+            'test-generation': ['test', 'generate', 'create test', 'unit test', 'spec'],
+            'coverage-analysis': ['coverage', 'gap', 'branch', 'uncovered'],
+            'security-compliance': ['security', 'vulnerability', 'owasp', 'injection', 'auth'],
+            'quality-assessment': ['quality', 'review', 'code review', 'assessment'],
+            'defect-intelligence': ['defect', 'bug', 'regression', 'root cause'],
+        };
+        for (const [domain, terms] of Object.entries(domainMap)) {
+            if (terms.some(t => desc.includes(t))) {
+                keywords.push(domain);
+            }
+        }
+        return keywords.length > 0 ? keywords : ['test-generation']; // default
+    }
+}
+//# sourceMappingURL=memory-source.js.map

package/dist/context/sources/test-source.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Test Source - Existing tests for target files
+ */
+import type { ContextSource, ContextRequest, ContextFragment } from './types.js';
+export declare class TestContextSource implements ContextSource {
+    id: string;
+    name: string;
+    priority: number;
+    maxTokens: number;
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+    private findTestPaths;
+}
+//# sourceMappingURL=test-source.d.ts.map

package/dist/context/sources/test-source.js

@@ -0,0 +1,53 @@
+/**
+ * Test Source - Existing tests for target files
+ */
+import { existsSync, readFileSync } from 'fs';
+import { basename, dirname, join } from 'path';
+export class TestContextSource {
+    id = 'tests';
+    name = 'Existing Tests';
+    priority = 70;
+    maxTokens = 2000;
+    async gather(request) {
+        const fragments = [];
+        for (const file of request.targetFiles.slice(0, 3)) {
+            const testPaths = this.findTestPaths(file);
+            for (const testPath of testPaths) {
+                if (existsSync(testPath)) {
+                    try {
+                        const content = readFileSync(testPath, 'utf-8');
+                        // Extract test names only (not full bodies) to save tokens
+                        const testNames = content.match(/(?:it|test|describe)\s*\(\s*['"`]([^'"`]+)['"`]/g) || [];
+                        if (testNames.length > 0) {
+                            const summary = `Tests for ${basename(file)} (${testPath}):\n${testNames.join('\n')}`;
+                            fragments.push({
+                                sourceId: this.id,
+                                title: `Tests: ${basename(file)}`,
+                                content: summary,
+                                estimatedTokens: Math.ceil(summary.length / 3.5),
+                                relevance: 0.8,
+                            });
+                        }
+                    }
+                    catch {
+                        // File read failed — skip
+                    }
+                }
+            }
+        }
+        return fragments;
+    }
+    findTestPaths(filePath) {
+        const base = basename(filePath).replace(/\.(ts|js|tsx|jsx)$/, '');
+        const dir = dirname(filePath);
+        const extensions = ['.test.ts', '.spec.ts', '.test.js', '.spec.js'];
+        const paths = [];
+        for (const ext of extensions) {
+            paths.push(join(dir, `${base}${ext}`));
+            paths.push(join(dir, '__tests__', `${base}${ext}`));
+            paths.push(join(dir, '..', 'tests', `${base}${ext}`));
+        }
+        return paths;
+    }
+}
+//# sourceMappingURL=test-source.js.map

package/dist/context/sources/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Context Source Types (BMAD-005)
+ */
+export interface ContextRequest {
+    /** Target files to gather context for */
+    targetFiles: string[];
+    /** Agent type requesting context */
+    agentType: string;
+    /** Task description */
+    taskDescription: string;
+    /** Maximum token budget across all sources */
+    maxTokenBudget?: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface ContextFragment {
+    /** Source identifier */
+    sourceId: string;
+    /** Fragment title */
+    title: string;
+    /** Fragment content */
+    content: string;
+    /** Estimated token count (chars / 3.5 with safety margin) */
+    estimatedTokens: number;
+    /** Relevance score 0-1 */
+    relevance: number;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+export interface ContextSource {
+    /** Source identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Priority (higher = more important, included first) */
+    priority: number;
+    /** Maximum tokens this source can use */
+    maxTokens: number;
+    /** Gather context fragments */
+    gather(request: ContextRequest): Promise<ContextFragment[]>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/context/sources/types.js

@@ -0,0 +1,5 @@
+/**
+ * Context Source Types (BMAD-005)
+ */
+export {};
+//# sourceMappingURL=types.js.map