@eddacraft/anvil-adapters 0.1.0

package/dist/aps-markdown/adapter.js

@@ -0,0 +1,351 @@
+/**
+ * APS Markdown Format Adapter
+ *
+ * FormatAdapter implementation for Anvil Plan Spec (APS) markdown format.
+ * Handles both leaf specs (.aps.md with Tasks section) and index files
+ * (.aps.md with Modules section).
+ */
+import { generatePlanId, generateHash, APS_SCHEMA_VERSION, } from '@eddacraft/anvil-core';
+import { parseDocument } from '@eddacraft/anvil-aps';
+import { BaseFormatAdapter, } from '../base/types.js';
+import { createDetection } from '../base/utils.js';
+/**
+ * APS Markdown FormatAdapter implementation
+ *
+ * Converts between APS markdown documents and APS plans.
+ */
+export class APSMarkdownAdapter extends BaseFormatAdapter {
+    metadata = {
+        name: 'aps-markdown',
+        version: '1.0.0',
+        displayName: 'Anvil Plan Spec Markdown',
+        description: 'APS markdown format adapter for plan specs (.aps.md)',
+        formats: ['aps', 'aps-markdown', 'aps.md'],
+        extensions: ['.aps.md'],
+    };
+    /**
+     * Detect if content is APS markdown format
+     *
+     * Uses confidence scoring based on multiple indicators:
+     * - Tasks section with SCOPE-NNN headings (30 points)
+     * - **Intent:** field in tasks (20 points)
+     * - Modules section (25 points)
+     * - .aps.md path links (20 points)
+     * - **Scope:** field (10 points)
+     * - **Confidence:** field (10 points)
+     * - **Owner:** field (5 points)
+     * - **Priority:** field (5 points)
+     *
+     * @param content - Document content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content) {
+        const indicators = this.analyzeContent(content);
+        const confidence = this.calculateConfidence(indicators);
+        const reason = this.buildDetectionReason(indicators);
+        // Detection threshold: 50% confidence
+        return createDetection(confidence >= 50, confidence, reason);
+    }
+    /**
+     * Parse APS markdown content to APS plan
+     *
+     * Converts an APS markdown document (leaf spec) to an APSPlan execution schema.
+     * Each task in the document becomes a proposed change in the plan.
+     *
+     * @param content - APS markdown content
+     * @param context - Parse context for provenance
+     * @param _options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    async parse(content, context, _options) {
+        try {
+            const doc = await parseDocument(content, context?.repositoryPath);
+            const plan = this.convertToAPSPlan(doc, context);
+            return this.createParseSuccess(plan);
+        }
+        catch (error) {
+            return this.createParseError([
+                {
+                    code: 'PARSE_ERROR',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            ]);
+        }
+    }
+    /**
+     * Convert a parsed document to an APSPlan
+     */
+    convertToAPSPlan(doc, context) {
+        const planId = context?.planId ?? generatePlanId();
+        const timestamp = context?.timestamp ?? new Date().toISOString();
+        const intent = doc.metadata?.scope ? `${doc.title} (Scope: ${doc.metadata.scope})` : doc.title;
+        const proposed_changes = doc.tasks.map((task) => this.taskToChange(task));
+        const planWithoutHash = {
+            schema_version: APS_SCHEMA_VERSION,
+            id: planId,
+            intent,
+            proposed_changes,
+            provenance: {
+                timestamp,
+                author: context?.author ?? process.env['USER'] ?? 'unknown',
+                source: 'cli',
+                version: this.metadata.version,
+                repository: context?.repositoryPath ?? process.cwd(),
+                branch: context?.branch ?? 'main',
+                commit: context?.commit ?? '',
+            },
+            validations: {
+                required_checks: ['lint', 'test'],
+                skip_checks: [],
+            },
+            evidence: [],
+            executions: [],
+        };
+        const hash = generateHash(planWithoutHash);
+        return { ...planWithoutHash, hash };
+    }
+    /**
+     * Convert a task to a change object
+     */
+    taskToChange(task) {
+        const changeType = this.inferChangeType(task);
+        return {
+            type: changeType,
+            path: task.files?.[0] ?? `task/${task.id}`,
+            description: `${task.id}: ${task.title}\n\n${task.intent}`,
+            metadata: {
+                taskId: task.id,
+                confidence: task.confidence,
+                validation: task.validation,
+                expectedOutcome: task.expectedOutcome,
+                tags: task.tags,
+                files: task.files,
+                scopes: task.scopes,
+                dependencies: task.dependencies,
+                risks: task.risks,
+                packages: task.packages,
+            },
+        };
+    }
+    /**
+     * Infer the change type from task intent
+     */
+    inferChangeType(task) {
+        const intent = task.intent.toLowerCase();
+        const title = task.title.toLowerCase();
+        if (intent.includes('create') ||
+            intent.includes('add') ||
+            title.includes('implement') ||
+            title.includes('create')) {
+            return 'file_create';
+        }
+        if (intent.includes('update') ||
+            intent.includes('modify') ||
+            intent.includes('fix') ||
+            title.includes('update') ||
+            title.includes('fix')) {
+            return 'file_update';
+        }
+        if (intent.includes('delete') ||
+            intent.includes('remove') ||
+            title.includes('delete') ||
+            title.includes('remove')) {
+            return 'file_delete';
+        }
+        if (intent.includes('config') || intent.includes('setting')) {
+            return 'config_update';
+        }
+        return 'script_execute';
+    }
+    /**
+     * Serialize APS plan to APS markdown format
+     *
+     * NOTE: Not yet implemented - returns NOT_IMPLEMENTED error.
+     *
+     * @param _plan - APS plan to serialize
+     * @param _options - Adapter options
+     * @returns Serialize result with APS markdown
+     */
+    async serialize(_plan, _options) {
+        return this.createSerializeError([
+            {
+                code: 'NOT_IMPLEMENTED',
+                message: 'APSMarkdownAdapter.serialize() is not yet implemented',
+            },
+        ]);
+    }
+    /**
+     * Validate APS markdown content
+     *
+     * NOTE: Not yet implemented - returns NOT_IMPLEMENTED error.
+     *
+     * @param _content - APS markdown content to validate
+     * @param _options - Validation options
+     * @returns Validation result
+     */
+    async validate(_content, _options) {
+        return {
+            valid: false,
+            issues: [
+                {
+                    code: 'NOT_IMPLEMENTED',
+                    path: '',
+                    message: 'APSMarkdownAdapter.validate() is not yet implemented',
+                    severity: 'error',
+                },
+            ],
+            summary: 'Validation not yet implemented',
+        };
+    }
+    /**
+     * Override canImport to handle the compound extension .aps.md
+     */
+    canImport(format) {
+        const normalized = format.toLowerCase().replace(/^\./, '');
+        return (this.metadata.formats.includes(normalized) ||
+            this.metadata.extensions.some((ext) => ext.replace(/^\./, '') === normalized) ||
+            normalized === 'aps.md');
+    }
+    /**
+     * Analyze content for APS markdown indicators
+     */
+    analyzeContent(content) {
+        // Check for H1 title
+        const hasH1Title = /^#\s+.+$/m.test(content);
+        // Check for **Scope:** or **ID:** field (ID is the current spec, Scope is legacy)
+        const hasScopeField = /\*\*Scope:\*\*\s*\S+/i.test(content) || /\*\*ID:\*\*\s*\S+/i.test(content);
+        // Check for ## Tasks section
+        const hasTasksSection = /^##\s+Tasks\s*$/im.test(content);
+        // Check for ## Modules section
+        const hasModulesSection = /^##\s+Modules\s*$/im.test(content);
+        // Check for SCOPE-NNN pattern in ### headings (e.g., ### AUTH-001: Description)
+        const scopeTaskPattern = /^###\s+[A-Z]{2,10}-\d{3}:/gm;
+        const taskPatternMatches = content.match(scopeTaskPattern) || [];
+        const hasScopeTaskPattern = taskPatternMatches.length > 0;
+        const taskPatternCount = taskPatternMatches.length;
+        // Check for **Intent:** field
+        const hasIntentField = /\*\*Intent:\*\*/i.test(content);
+        // Check for **Path:** with .aps.md links
+        const apsLinkPattern = /\*\*Path:\*\*\s*\[.*?\]\([^)]*\.aps\.md\)/gi;
+        const apsLinkMatches = content.match(apsLinkPattern) || [];
+        const hasAPSModuleLinks = apsLinkMatches.length > 0;
+        const apsLinkCount = apsLinkMatches.length;
+        // Check for **Confidence:** field
+        const hasConfidenceField = /\*\*Confidence:\*\*/i.test(content);
+        // Check for **Owner:** field
+        const hasOwnerField = /\*\*Owner:\*\*/i.test(content);
+        // Check for **Priority:** field
+        const hasPriorityField = /\*\*Priority:\*\*/i.test(content);
+        // Check for **Packages:** field (monorepo support)
+        const hasPackagesField = /\*\*Packages:\*\*/i.test(content);
+        return {
+            hasH1Title,
+            hasScopeField,
+            hasTasksSection,
+            hasModulesSection,
+            hasScopeTaskPattern,
+            hasIntentField,
+            hasAPSModuleLinks,
+            hasConfidenceField,
+            hasOwnerField,
+            hasPriorityField,
+            hasPackagesField,
+            taskPatternCount,
+            apsLinkCount,
+        };
+    }
+    /**
+     * Calculate confidence score based on indicators
+     */
+    calculateConfidence(indicators) {
+        let score = 0;
+        // Leaf spec indicators (Tasks section path)
+        if (indicators.hasTasksSection) {
+            score += 15; // Has ## Tasks section
+            if (indicators.hasScopeTaskPattern) {
+                score += 30; // Has SCOPE-NNN task IDs
+                // Bonus for multiple tasks
+                if (indicators.taskPatternCount > 1) {
+                    score += 5;
+                }
+            }
+            if (indicators.hasIntentField) {
+                score += 20; // Has **Intent:** in tasks
+            }
+        }
+        // Index file indicators (Modules section path)
+        if (indicators.hasModulesSection) {
+            score += 20; // Has ## Modules section
+            if (indicators.hasAPSModuleLinks) {
+                score += 25; // Has .aps.md path links
+                // Bonus for multiple modules
+                if (indicators.apsLinkCount > 1) {
+                    score += 5;
+                }
+            }
+        }
+        // Common APS metadata fields
+        if (indicators.hasScopeField) {
+            score += 10; // Has **Scope:** field
+        }
+        if (indicators.hasConfidenceField) {
+            score += 10; // Has **Confidence:** field
+        }
+        if (indicators.hasOwnerField) {
+            score += 5; // Has **Owner:** field
+        }
+        if (indicators.hasPriorityField) {
+            score += 5; // Has **Priority:** field
+        }
+        if (indicators.hasPackagesField) {
+            score += 5; // Has **Packages:** field (monorepo support)
+        }
+        return Math.min(100, score);
+    }
+    /**
+     * Build detection reason message
+     */
+    buildDetectionReason(indicators) {
+        const reasons = [];
+        if (indicators.hasTasksSection) {
+            reasons.push('tasks-section');
+        }
+        if (indicators.hasScopeTaskPattern) {
+            reasons.push(`scope-tasks(${indicators.taskPatternCount})`);
+        }
+        if (indicators.hasIntentField) {
+            reasons.push('intent-field');
+        }
+        if (indicators.hasModulesSection) {
+            reasons.push('modules-section');
+        }
+        if (indicators.hasAPSModuleLinks) {
+            reasons.push(`aps-links(${indicators.apsLinkCount})`);
+        }
+        if (indicators.hasScopeField) {
+            reasons.push('scope-field');
+        }
+        if (indicators.hasConfidenceField) {
+            reasons.push('confidence-field');
+        }
+        if (indicators.hasOwnerField) {
+            reasons.push('owner-field');
+        }
+        if (indicators.hasPriorityField) {
+            reasons.push('priority-field');
+        }
+        if (indicators.hasPackagesField) {
+            reasons.push('packages-field');
+        }
+        return reasons.length > 0 ? reasons.join(', ') : 'no APS indicators';
+    }
+}
+/**
+ * Create a new APS markdown adapter instance
+ *
+ * @param options - Adapter options
+ * @returns APS markdown adapter instance
+ */
+export function createAPSMarkdownAdapter(options) {
+    return new APSMarkdownAdapter(options);
+}

package/dist/aps-markdown/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * APS Markdown Adapter
+ *
+ * Exports the APSMarkdownAdapter for detecting and converting
+ * Anvil Plan Spec markdown documents.
+ */
+export { APSMarkdownAdapter, createAPSMarkdownAdapter } from './adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/aps-markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aps-markdown/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC"}

package/dist/aps-markdown/index.js

@@ -0,0 +1,7 @@
+/**
+ * APS Markdown Adapter
+ *
+ * Exports the APSMarkdownAdapter for detecting and converting
+ * Anvil Plan Spec markdown documents.
+ */
+export { APSMarkdownAdapter, createAPSMarkdownAdapter } from './adapter.js';

package/dist/base/file-discovery.d.ts

@@ -0,0 +1,63 @@
+/**
+ * File Discovery Utility
+ *
+ * Discovers planning documents in repositories by searching for common patterns.
+ */
+/**
+ * Discovered planning file
+ */
+export interface DiscoveredFile {
+    /** Full path to file */
+    path: string;
+    /** File name */
+    name: string;
+    /** File size in bytes */
+    size: number;
+    /** Last modified timestamp */
+    modified: Date;
+    /** Confidence score that this is a planning document (0-100) */
+    confidence: number;
+    /** Reason for detection */
+    reason: string;
+}
+/**
+ * Search options
+ */
+export interface SearchOptions {
+    /** Root directory to search from */
+    rootPath: string;
+    /** Maximum depth to search */
+    maxDepth?: number;
+    /** Directories to exclude */
+    excludeDirs?: string[];
+    /** File patterns to search for */
+    patterns?: string[];
+}
+/**
+ * Discover planning documents in a directory
+ *
+ * Searches for common planning document patterns like prd.md, plan.md, todo.md, etc.
+ *
+ * @param options - Search options
+ * @returns Array of discovered files, sorted by confidence
+ */
+export declare function discoverPlanningFiles(options: SearchOptions): Promise<DiscoveredFile[]>;
+/**
+ * Find the most likely planning document
+ *
+ * Returns the single most likely planning document based on confidence and recency.
+ *
+ * @param options - Search options
+ * @returns The most likely planning document, or undefined if none found
+ */
+export declare function findBestPlanningFile(options: SearchOptions): Promise<DiscoveredFile | undefined>;
+/**
+ * Group discovered files by name pattern
+ *
+ * Groups files like "prd.md", "plan.md" etc. for easier selection.
+ *
+ * @param files - Discovered files
+ * @returns Map of pattern to files
+ */
+export declare function groupFilesByPattern(files: DiscoveredFile[]): Map<string, DiscoveredFile[]>;
+//# sourceMappingURL=file-discovery.d.ts.map

package/dist/base/file-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-discovery.d.ts","sourceRoot":"","sources":["../../src/base/file-discovery.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,8BAA8B;IAC9B,QAAQ,EAAE,IAAI,CAAC;IACf,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6BAA6B;IAC7B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAiMD;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAiB7F;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CAGrC;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAsB1F"}

package/dist/base/file-discovery.js

@@ -0,0 +1,246 @@
+/**
+ * File Discovery Utility
+ *
+ * Discovers planning documents in repositories by searching for common patterns.
+ */
+import { readdir, stat } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+/**
+ * Maximum file size to consider (2MB)
+ */
+const MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
+/**
+ * Maximum directory depth for recursive search
+ */
+const MAX_DEPTH = 20;
+/**
+ * Default directories to exclude
+ */
+const DEFAULT_EXCLUDE_DIRS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.nuxt',
+    'out',
+    'target',
+    'vendor',
+];
+/**
+ * Default file patterns for planning documents
+ */
+const DEFAULT_PATTERNS = [
+    'prd',
+    'plan',
+    'todo',
+    'tasks',
+    'spec',
+    'requirements',
+    'rfc',
+    'adr',
+    'design',
+    'proposal',
+    'roadmap',
+];
+/**
+ * Calculate confidence score for a file name
+ */
+function calculateFileConfidence(filename) {
+    const lower = filename.toLowerCase();
+    let confidence = 0;
+    const reasons = [];
+    // Exact matches (high confidence)
+    const exactMatches = ['prd.md', 'plan.md', 'todo.md', 'tasks.md', 'spec.md', 'requirements.md'];
+    if (exactMatches.some((pattern) => lower === pattern)) {
+        confidence += 80;
+        reasons.push('exact-match');
+    }
+    // Pattern matches (medium-high confidence)
+    if (lower.includes('prd')) {
+        confidence += 60;
+        reasons.push('prd-pattern');
+    }
+    if (lower.includes('plan')) {
+        confidence += 55;
+        reasons.push('plan-pattern');
+    }
+    if (lower.includes('todo')) {
+        confidence += 50;
+        reasons.push('todo-pattern');
+    }
+    if (lower.includes('spec')) {
+        confidence += 50;
+        reasons.push('spec-pattern');
+    }
+    if (lower.includes('requirements')) {
+        confidence += 55;
+        reasons.push('requirements-pattern');
+    }
+    if (lower.includes('task')) {
+        confidence += 45;
+        reasons.push('task-pattern');
+    }
+    if (lower.includes('rfc')) {
+        confidence += 50;
+        reasons.push('rfc-pattern');
+    }
+    if (lower.includes('adr')) {
+        confidence += 50;
+        reasons.push('adr-pattern');
+    }
+    if (lower.includes('design')) {
+        confidence += 40;
+        reasons.push('design-pattern');
+    }
+    if (lower.includes('proposal')) {
+        confidence += 45;
+        reasons.push('proposal-pattern');
+    }
+    // Check for common planning directories
+    if (lower.includes('docs/') || lower.includes('/docs/')) {
+        confidence += 10;
+        reasons.push('in-docs-dir');
+    }
+    if (lower.includes('.anvil/') || lower.includes('/.anvil/')) {
+        confidence += 15;
+        reasons.push('in-anvil-dir');
+    }
+    // Markdown extension
+    if (lower.endsWith('.md') || lower.endsWith('.markdown')) {
+        confidence += 5;
+        reasons.push('markdown');
+    }
+    return {
+        confidence: Math.min(100, confidence),
+        reason: reasons.join(', ') || 'no-match',
+    };
+}
+/**
+ * Search directory recursively for planning files
+ */
+async function searchDirectory(dirPath, options, currentDepth = 0, results = []) {
+    // Stop if max depth reached (clamped to safety limit)
+    const effectiveMaxDepth = Math.min(options.maxDepth, MAX_DEPTH);
+    if (currentDepth > effectiveMaxDepth) {
+        return results;
+    }
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                // Skip excluded directories
+                if (options.excludeDirs.includes(entry.name)) {
+                    continue;
+                }
+                // Recurse into directory
+                await searchDirectory(fullPath, options, currentDepth + 1, results);
+            }
+            else if (entry.isFile()) {
+                // Check if file matches patterns
+                const lower = entry.name.toLowerCase();
+                const matchesPattern = options.patterns.some((pattern) => lower.includes(pattern));
+                if (matchesPattern && (lower.endsWith('.md') || lower.endsWith('.markdown'))) {
+                    try {
+                        const stats = await stat(fullPath);
+                        // Skip files exceeding size limit
+                        if (stats.size > MAX_FILE_SIZE_BYTES) {
+                            continue;
+                        }
+                        const { confidence, reason } = calculateFileConfidence(fullPath);
+                        if (confidence >= 40) {
+                            // Threshold for inclusion
+                            results.push({
+                                path: fullPath,
+                                name: entry.name,
+                                size: stats.size,
+                                modified: stats.mtime,
+                                confidence,
+                                reason,
+                            });
+                        }
+                    }
+                    catch (statError) {
+                        console.error(`[FileDiscovery] Failed to stat file ${fullPath}:`, statError);
+                    }
+                }
+            }
+        }
+    }
+    catch (readError) {
+        console.error(`[FileDiscovery] Failed to read directory ${dirPath}:`, readError);
+    }
+    return results;
+}
+/**
+ * Discover planning documents in a directory
+ *
+ * Searches for common planning document patterns like prd.md, plan.md, todo.md, etc.
+ *
+ * @param options - Search options
+ * @returns Array of discovered files, sorted by confidence
+ */
+export async function discoverPlanningFiles(options) {
+    const searchOptions = {
+        rootPath: options.rootPath,
+        maxDepth: options.maxDepth ?? 5,
+        excludeDirs: options.excludeDirs ?? DEFAULT_EXCLUDE_DIRS,
+        patterns: options.patterns ?? DEFAULT_PATTERNS,
+    };
+    const results = await searchDirectory(searchOptions.rootPath, searchOptions);
+    // Sort by confidence (descending), then by modified date (newest first)
+    return results.sort((a, b) => {
+        if (a.confidence !== b.confidence) {
+            return b.confidence - a.confidence;
+        }
+        return b.modified.getTime() - a.modified.getTime();
+    });
+}
+/**
+ * Find the most likely planning document
+ *
+ * Returns the single most likely planning document based on confidence and recency.
+ *
+ * @param options - Search options
+ * @returns The most likely planning document, or undefined if none found
+ */
+export async function findBestPlanningFile(options) {
+    const files = await discoverPlanningFiles(options);
+    return files[0];
+}
+/**
+ * Group discovered files by name pattern
+ *
+ * Groups files like "prd.md", "plan.md" etc. for easier selection.
+ *
+ * @param files - Discovered files
+ * @returns Map of pattern to files
+ */
+export function groupFilesByPattern(files) {
+    const groups = new Map();
+    for (const file of files) {
+        const lower = basename(file.name).toLowerCase();
+        let pattern = 'other';
+        if (lower.includes('prd'))
+            pattern = 'prd';
+        else if (lower.includes('plan'))
+            pattern = 'plan';
+        else if (lower.includes('todo'))
+            pattern = 'todo';
+        else if (lower.includes('spec'))
+            pattern = 'spec';
+        else if (lower.includes('requirements'))
+            pattern = 'requirements';
+        else if (lower.includes('rfc'))
+            pattern = 'rfc';
+        else if (lower.includes('adr'))
+            pattern = 'adr';
+        if (!groups.has(pattern)) {
+            groups.set(pattern, []);
+        }
+        groups.get(pattern).push(file);
+    }
+    return groups;
+}

package/dist/base/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Base Adapter Framework
+ *
+ * Core types, interfaces, and registry for format adapters.
+ */
+export * from './types.js';
+export * from './registry.js';
+export * from './utils.js';
+export * from './file-discovery.js';
+//# sourceMappingURL=index.d.ts.map