@eddacraft/anvil-adapters 0.1.0

package/dist/generic/utils.js

@@ -0,0 +1,232 @@
+/**
+ * Generic Adapter Utilities
+ *
+ * Helper functions for parsing generic markdown documents.
+ */
+/**
+ * Extract document title from first heading
+ */
+export function extractTitle(content) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match ? match[1].trim() : undefined;
+}
+/**
+ * Extract intent from common sections
+ */
+export function extractIntent(content) {
+    // Look for sections like: Purpose, Intent, Objective, Goal, Summary
+    const patterns = [
+        /##\s+(?:Purpose|Intent|Objective|Goal)\s*\n+([^\n#]+)/i,
+        /##\s+(?:Executive\s+)?Summary\s*\n+([^\n#]+)/i,
+        /^([^#\n]+?)(?=\n##|\n#|$)/m, // First paragraph as fallback
+    ];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match && match[1]) {
+            return match[1].trim().substring(0, 500); // Limit length
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract overview/description
+ */
+export function extractOverview(content) {
+    const patterns = [/##\s+(?:Overview|Description|Background|Context)\s*\n+([\s\S]+?)(?=\n##|$)/i];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match && match[1]) {
+            return match[1].trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract goals from lists under Goals/Objectives sections
+ */
+export function extractGoals(content) {
+    const goals = [];
+    // Match Goals/Objectives section
+    const sectionMatch = content.match(/##\s+(?:Goals?|Objectives?)\s*\n+([\s\S]+?)(?=\n##|$)/i);
+    if (sectionMatch) {
+        const section = sectionMatch[1];
+        // Extract list items
+        const listItems = section.match(/^[-*]\s+(.+)$/gm);
+        if (listItems) {
+            goals.push(...listItems.map((item) => item.replace(/^[-*]\s+/, '').trim()));
+        }
+    }
+    return goals;
+}
+/**
+ * Extract requirements from various sections
+ */
+export function extractRequirements(content) {
+    const requirements = [];
+    // Match Requirements/Needs/Must Have sections
+    const patterns = [
+        /##\s+(?:Requirements?|Needs?|Must\s+Have)\s*\n+([\s\S]+?)(?=\n##|$)/i,
+        /##\s+(?:Functional\s+)?Requirements?\s*\n+([\s\S]+?)(?=\n##|$)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match) {
+            const section = match[1];
+            // Extract list items
+            const listItems = section.match(/^[-*]\s+(.+)$/gm);
+            if (listItems) {
+                requirements.push(...listItems.map((item) => item.replace(/^[-*]\s+/, '').trim()));
+            }
+            // Extract numbered items
+            const numberedItems = section.match(/^\d+\.\s+(.+)$/gm);
+            if (numberedItems) {
+                requirements.push(...numberedItems.map((item) => item.replace(/^\d+\.\s+/, '').trim()));
+            }
+        }
+    }
+    return requirements;
+}
+/**
+ * Extract tasks from Tasks/Action Items sections
+ */
+export function extractTasks(content) {
+    const tasks = [];
+    const patterns = [/##\s+(?:Tasks?|Action\s+Items?|To\s+Do|TODO)\s*\n+([\s\S]+?)(?=\n##|$)/i];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match) {
+            const section = match[1];
+            // Extract list items (including checkboxes)
+            const listItems = section.match(/^[-*]\s+(?:\[[ x]\]\s+)?(.+)$/gm);
+            if (listItems) {
+                tasks.push(...listItems.map((item) => item.replace(/^[-*]\s+(?:\[[ x]\]\s+)?/, '').trim()));
+            }
+        }
+    }
+    return tasks;
+}
+/**
+ * Extract features from Features/Capabilities sections
+ */
+export function extractFeatures(content) {
+    const features = [];
+    const patterns = [/##\s+(?:Features?|Capabilities?|Functionality)\s*\n+([\s\S]+?)(?=\n##|$)/i];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match) {
+            const section = match[1];
+            const listItems = section.match(/^[-*]\s+(.+)$/gm);
+            if (listItems) {
+                features.push(...listItems.map((item) => item.replace(/^[-*]\s+/, '').trim()));
+            }
+        }
+    }
+    return features;
+}
+/**
+ * Analyze content for generic markdown indicators
+ */
+export function analyzeContent(content) {
+    const headings = content.match(/^#{1,6}\s+.+$/gm) || [];
+    const listItems = content.match(/^[-*]\s+.+$/gm) || [];
+    const words = content.split(/\s+/).filter((w) => w.length > 0);
+    return {
+        hasHeadings: headings.length > 0,
+        hasLists: listItems.length > 0,
+        hasRequirementsSection: /##\s+(?:Requirements?|Needs?)/i.test(content),
+        hasGoalsSection: /##\s+(?:Goals?|Objectives?)/i.test(content),
+        hasTasksSection: /##\s+(?:Tasks?|Action\s+Items?|To\s+Do)/i.test(content),
+        hasFeaturesSection: /##\s+(?:Features?|Capabilities?)/i.test(content),
+        hasOverviewSection: /##\s+(?:Overview|Description|Background)/i.test(content),
+        wordCount: words.length,
+        listItemCount: listItems.length,
+    };
+}
+/**
+ * Calculate confidence score for generic markdown detection
+ */
+export function calculateConfidenceScore(indicators) {
+    let score = 0;
+    // Basic markdown structure (10 points)
+    if (indicators.hasHeadings) {
+        score += 10;
+    }
+    // Has lists (10 points)
+    if (indicators.hasLists) {
+        score += 10;
+    }
+    // Planning-related sections (5 points each)
+    if (indicators.hasRequirementsSection) {
+        score += 5;
+    }
+    if (indicators.hasGoalsSection) {
+        score += 5;
+    }
+    if (indicators.hasTasksSection) {
+        score += 5;
+    }
+    if (indicators.hasFeaturesSection) {
+        score += 5;
+    }
+    if (indicators.hasOverviewSection) {
+        score += 5;
+    }
+    // Content density (up to 10 points)
+    if (indicators.wordCount >= 100) {
+        score += 5;
+    }
+    if (indicators.wordCount >= 500) {
+        score += 5;
+    }
+    // List items (up to 5 points)
+    if (indicators.listItemCount >= 3) {
+        score += 3;
+    }
+    if (indicators.listItemCount >= 10) {
+        score += 2;
+    }
+    return Math.min(100, score);
+}
+/**
+ * Build detection reason string
+ */
+export function buildDetectionReason(indicators) {
+    const reasons = [];
+    if (indicators.hasHeadings) {
+        reasons.push('markdown-headings');
+    }
+    if (indicators.hasLists) {
+        reasons.push(`${indicators.listItemCount} list-items`);
+    }
+    if (indicators.hasRequirementsSection) {
+        reasons.push('requirements-section');
+    }
+    if (indicators.hasGoalsSection) {
+        reasons.push('goals-section');
+    }
+    if (indicators.hasTasksSection) {
+        reasons.push('tasks-section');
+    }
+    if (indicators.hasFeaturesSection) {
+        reasons.push('features-section');
+    }
+    if (indicators.hasOverviewSection) {
+        reasons.push('overview-section');
+    }
+    return reasons.length > 0 ? reasons.join(', ') : 'generic-markdown';
+}
+/**
+ * Parse generic markdown document
+ */
+export function parseGenericDocument(content) {
+    return {
+        title: extractTitle(content),
+        intent: extractIntent(content),
+        overview: extractOverview(content),
+        goals: extractGoals(content),
+        requirements: extractRequirements(content),
+        tasks: extractTasks(content),
+        features: extractFeatures(content),
+        raw: content,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Anvil Adapters Package
+ *
+ * Provides format adapters for converting between external planning formats
+ * (SpecKit, BMAD, etc.) and the Anvil Plan Spec (APS).
+ */
+export * from './base/index.js';
+export * from './aps-markdown/index.js';
+export * from './speckit/index.js';
+export * from './bmad/index.js';
+export * from './generic/index.js';
+export type { SpecContext, ExternalSpec, ConversionResult, ConversionError, ConversionWarning, } from './common/types.js';
+import { registry as baseRegistry } from './base/index.js';
+export { baseRegistry as registry };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,iBAAiB,CAAC;AAGhC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,iBAAiB,CAAC;AAGhC,cAAc,oBAAoB,CAAC;AAGnC,YAAY,EACV,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,QAAQ,IAAI,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAe3D,OAAO,EAAE,YAAY,IAAI,QAAQ,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * Anvil Adapters Package
+ *
+ * Provides format adapters for converting between external planning formats
+ * (SpecKit, BMAD, etc.) and the Anvil Plan Spec (APS).
+ */
+// Export base framework (types, registry, utils)
+export * from './base/index.js';
+// Export APS Markdown adapter (native format)
+export * from './aps-markdown/index.js';
+// Export SpecKit adapter
+export * from './speckit/index.js';
+// Export BMAD adapter
+export * from './bmad/index.js';
+// Export Generic adapter
+export * from './generic/index.js';
+// Auto-register adapters when module is imported
+import { registry as baseRegistry } from './base/index.js';
+import { APSMarkdownAdapter } from './aps-markdown/index.js';
+import { BMADFormatAdapter } from './bmad/index.js';
+import { SpecKitFormatAdapter } from './speckit/index.js';
+import { GenericMarkdownAdapter } from './generic/index.js';
+// Register adapters in priority order
+// APS adapter first (native format), then specific external formats
+// Generic adapter is registered last as fallback
+baseRegistry.register(new APSMarkdownAdapter());
+baseRegistry.register(new BMADFormatAdapter());
+baseRegistry.register(new SpecKitFormatAdapter());
+baseRegistry.register(new GenericMarkdownAdapter());
+// Export the registry instance as default export
+export { baseRegistry as registry };

package/dist/speckit/export.d.ts

@@ -0,0 +1,22 @@
+import type { APSPlan, ValidationResult } from '@eddacraft/anvil-core';
+import type { ConversionResult, ExternalSpec, SpecContext } from '../common/types.js';
+import { BaseAdapter } from '../common/types.js';
+export declare class SpecKitExportAdapter extends BaseAdapter {
+    readonly name = "speckit-export";
+    readonly version = "1.0.0";
+    readonly supportedFormats: readonly ["speckit", "spec.md"];
+    generateSpec(_intent: string, _context: SpecContext): Promise<APSPlan>;
+    validateSpec(spec: APSPlan): Promise<ValidationResult>;
+    convertToAPS(_spec: ExternalSpec): Promise<ConversionResult<APSPlan>>;
+    convertFromAPS(spec: APSPlan): Promise<ConversionResult<ExternalSpec>>;
+    private generateSpecMarkdown;
+    private generatePlanMarkdown;
+    private generateTasksMarkdown;
+    private groupChangesByType;
+    private formatChangeType;
+    private getFileExtension;
+    private filterCustomMetadata;
+    private convertChangesToSteps;
+    private convertChangesToTasks;
+}
+//# sourceMappingURL=export.d.ts.map

package/dist/speckit/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../src/speckit/export.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAU,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAEV,gBAAgB,EAEhB,YAAY,EACZ,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,qBAAa,oBAAqB,SAAQ,WAAW;IACnD,QAAQ,CAAC,IAAI,oBAAoB;IACjC,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,gBAAgB,kCAAmC;IAEtD,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAItE,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyCtD,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAYrE,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAyC5E,OAAO,CAAC,oBAAoB;IA0F5B,OAAO,CAAC,oBAAoB;IA0C5B,OAAO,CAAC,qBAAqB;IAsE7B,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,gBAAgB;IAwCxB,OAAO,CAAC,oBAAoB;IAa5B,OAAO,CAAC,qBAAqB;IAmC7B,OAAO,CAAC,qBAAqB;CAyD9B"}

package/dist/speckit/export.js

@@ -0,0 +1,384 @@
+import { BaseAdapter } from '../common/types.js';
+export class SpecKitExportAdapter extends BaseAdapter {
+    name = 'speckit-export';
+    version = '1.0.0';
+    supportedFormats = ['speckit', 'spec.md'];
+    async generateSpec(_intent, _context) {
+        throw new Error('Use speckit-import adapter for generating new specs');
+    }
+    async validateSpec(spec) {
+        const issues = [];
+        if (!spec.intent || spec.intent.length < 10) {
+            issues.push({
+                path: 'intent',
+                message: 'Intent is required and must be at least 10 characters',
+                code: 'INVALID_INTENT',
+                severity: 'error',
+            });
+        }
+        if (spec.proposed_changes.length === 0) {
+            issues.push({
+                path: 'proposed_changes',
+                message: 'No changes to export',
+                code: 'EMPTY_CHANGES',
+                severity: 'warning',
+            });
+        }
+        // Only errors make validation invalid, warnings are ok
+        const hasErrors = issues.some((issue) => issue.severity === 'error');
+        return {
+            valid: !hasErrors,
+            data: spec,
+            issues: issues.length > 0 ? issues : undefined,
+            summary: hasErrors
+                ? `Found ${issues.filter((i) => i.severity === 'error').length} error(s)`
+                : issues.length > 0
+                    ? `Validation passed with ${issues.length} warning(s)`
+                    : 'Validation passed',
+        };
+    }
+    async convertToAPS(_spec) {
+        return {
+            success: false,
+            errors: [
+                {
+                    code: 'NOT_IMPLEMENTED',
+                    message: 'Import from SpecKit format is handled by speckit-import adapter',
+                },
+            ],
+        };
+    }
+    async convertFromAPS(spec) {
+        const errors = [];
+        const warnings = [];
+        try {
+            const specContent = this.generateSpecMarkdown(spec);
+            const planContent = this.generatePlanMarkdown(spec);
+            const tasksContent = this.generateTasksMarkdown(spec);
+            const result = {
+                format: 'speckit',
+                version: '1.0.0',
+                content: {
+                    specContent,
+                    planContent,
+                    tasksContent,
+                    metadata: spec.metadata,
+                },
+                metadata: {
+                    generated_at: new Date().toISOString(),
+                    generator: this.name,
+                    generator_version: this.version,
+                    aps_id: spec.id,
+                    aps_hash: spec.hash,
+                },
+            };
+            return {
+                success: true,
+                data: result,
+                warnings: warnings.length > 0 ? warnings : undefined,
+            };
+        }
+        catch (error) {
+            errors.push({
+                code: 'EXPORT_ERROR',
+                message: error instanceof Error ? error.message : 'Failed to export to SpecKit format',
+            });
+            return { success: false, errors };
+        }
+    }
+    generateSpecMarkdown(spec) {
+        const sections = [];
+        sections.push(`# Specification`);
+        sections.push('');
+        sections.push(`## Intent`);
+        sections.push('');
+        sections.push(spec.intent);
+        sections.push('');
+        if (spec.metadata?.['overview']) {
+            sections.push(`## Overview`);
+            sections.push('');
+            sections.push(spec.metadata['overview']);
+            sections.push('');
+        }
+        if (spec.metadata?.['goals'] && Array.isArray(spec.metadata['goals'])) {
+            sections.push(`## Goals`);
+            sections.push('');
+            for (const goal of spec.metadata['goals']) {
+                sections.push(`- ${goal}`);
+            }
+            sections.push('');
+        }
+        if (spec.metadata?.['requirements'] && Array.isArray(spec.metadata['requirements'])) {
+            sections.push(`## Requirements`);
+            sections.push('');
+            for (const req of spec.metadata['requirements']) {
+                sections.push(`- ${req}`);
+            }
+            sections.push('');
+        }
+        if (spec.proposed_changes.length > 0) {
+            sections.push(`## Changes`);
+            sections.push('');
+            const changesByType = this.groupChangesByType(spec.proposed_changes);
+            for (const [type, changes] of Object.entries(changesByType)) {
+                if (changes.length > 0) {
+                    sections.push(`### ${this.formatChangeType(type)}`);
+                    sections.push('');
+                    for (const change of changes) {
+                        sections.push(`#### ${change.description}`);
+                        sections.push('');
+                        if (change.path) {
+                            sections.push(`Path: \`${change.path}\``);
+                            sections.push('');
+                        }
+                        if (change.content) {
+                            const extension = this.getFileExtension(change.path || '');
+                            sections.push(`\`\`\`${extension}`);
+                            sections.push(change.content);
+                            sections.push(`\`\`\``);
+                            sections.push('');
+                        }
+                        if (change.diff) {
+                            sections.push(`\`\`\`diff`);
+                            sections.push(change.diff);
+                            sections.push(`\`\`\``);
+                            sections.push('');
+                        }
+                    }
+                }
+            }
+        }
+        if (spec.metadata) {
+            const customMetadata = this.filterCustomMetadata(spec.metadata);
+            if (Object.keys(customMetadata).length > 0) {
+                sections.push(`## Metadata`);
+                sections.push('');
+                sections.push(`\`\`\`json`);
+                sections.push(JSON.stringify(customMetadata, null, 2));
+                sections.push(`\`\`\``);
+                sections.push('');
+            }
+        }
+        return sections.join('\n');
+    }
+    generatePlanMarkdown(spec) {
+        const sections = [];
+        sections.push(`# Implementation Plan`);
+        sections.push('');
+        sections.push(`Generated from APS: ${spec.id}`);
+        sections.push('');
+        sections.push(`## Summary`);
+        sections.push('');
+        sections.push(spec.intent);
+        sections.push('');
+        sections.push(`## Implementation Steps`);
+        sections.push('');
+        const steps = this.convertChangesToSteps(spec.proposed_changes);
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            sections.push(`${i + 1}. **${step.title}**`);
+            if (step.details) {
+                sections.push(`   - ${step.details}`);
+            }
+            if (step.dependencies.length > 0) {
+                sections.push(`   - Dependencies: ${step.dependencies.join(', ')}`);
+            }
+            sections.push('');
+        }
+        if (spec.validations) {
+            sections.push(`## Validation Requirements`);
+            sections.push('');
+            sections.push(`- Required checks: ${spec.validations.required_checks.join(', ')}`);
+            if (spec.validations.skip_checks.length > 0) {
+                sections.push(`- Skipped checks: ${spec.validations.skip_checks.join(', ')}`);
+            }
+            sections.push('');
+        }
+        return sections.join('\n');
+    }
+    generateTasksMarkdown(spec) {
+        const sections = [];
+        sections.push(`# Tasks`);
+        sections.push('');
+        sections.push(`Generated from APS: ${spec.id}`);
+        sections.push(`Last updated: ${new Date().toISOString()}`);
+        sections.push('');
+        sections.push(`## Task List`);
+        sections.push('');
+        const tasks = this.convertChangesToTasks(spec.proposed_changes);
+        let completedCount = 0;
+        for (const task of tasks) {
+            const status = task.completed ? 'x' : ' ';
+            const statusEmoji = task.completed ? '✅' : '⏳';
+            sections.push(`- [${status}] ${statusEmoji} ${task.description}`);
+            if (task.subtasks.length > 0) {
+                for (const subtask of task.subtasks) {
+                    const subStatus = subtask.completed ? 'x' : ' ';
+                    sections.push(`  - [${subStatus}] ${subtask.description}`);
+                }
+            }
+            if (task.completed) {
+                completedCount++;
+            }
+        }
+        sections.push('');
+        sections.push(`## Progress`);
+        sections.push('');
+        sections.push(`- Total tasks: ${tasks.length}`);
+        sections.push(`- Completed: ${completedCount}`);
+        sections.push(`- Remaining: ${tasks.length - completedCount}`);
+        sections.push(`- Progress: ${Math.round((completedCount / tasks.length) * 100)}%`);
+        sections.push('');
+        if (spec.executions && spec.executions.length > 0) {
+            sections.push(`## Execution History`);
+            sections.push('');
+            for (const execution of spec.executions) {
+                sections.push(`### ${new Date(execution.timestamp).toLocaleString()}`);
+                sections.push(`- Operation: ${execution.operation}`);
+                sections.push(`- Status: ${execution.status}`);
+                if (execution.executed_by) {
+                    sections.push(`- Executed by: ${execution.executed_by}`);
+                }
+                if (execution.changes_applied && execution.changes_applied.length > 0) {
+                    sections.push(`- Applied changes: ${execution.changes_applied.join(', ')}`);
+                }
+                if (execution.changes_failed && execution.changes_failed.length > 0) {
+                    sections.push(`- Failed changes: ${execution.changes_failed.join(', ')}`);
+                }
+                if (execution.logs && execution.logs.length > 0) {
+                    for (const log of execution.logs) {
+                        sections.push(`- ${log}`);
+                    }
+                }
+                sections.push('');
+            }
+        }
+        return sections.join('\n');
+    }
+    groupChangesByType(changes) {
+        const groups = {};
+        for (const change of changes) {
+            if (!groups[change.type]) {
+                groups[change.type] = [];
+            }
+            groups[change.type].push(change);
+        }
+        return groups;
+    }
+    formatChangeType(type) {
+        const typeMap = {
+            file_create: 'Files to Create',
+            file_update: 'Files to Update',
+            file_delete: 'Files to Delete',
+            config_update: 'Configuration Changes',
+            dependency_add: 'Dependencies to Add',
+            dependency_remove: 'Dependencies to Remove',
+            dependency_update: 'Dependencies to Update',
+            script_execute: 'Scripts to Execute',
+        };
+        return typeMap[type] || type.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase());
+    }
+    getFileExtension(path) {
+        const ext = path.split('.').pop()?.toLowerCase();
+        const extMap = {
+            js: 'javascript',
+            ts: 'typescript',
+            jsx: 'javascript',
+            tsx: 'typescript',
+            py: 'python',
+            rb: 'ruby',
+            go: 'go',
+            rs: 'rust',
+            java: 'java',
+            cpp: 'cpp',
+            c: 'c',
+            h: 'c',
+            hpp: 'cpp',
+            cs: 'csharp',
+            php: 'php',
+            swift: 'swift',
+            kt: 'kotlin',
+            scala: 'scala',
+            r: 'r',
+            m: 'matlab',
+            sh: 'bash',
+            ps1: 'powershell',
+            sql: 'sql',
+            md: 'markdown',
+            yml: 'yaml',
+            yaml: 'yaml',
+            json: 'json',
+            xml: 'xml',
+            html: 'html',
+            css: 'css',
+            scss: 'scss',
+            less: 'less',
+        };
+        return extMap[ext || ''] || ext || 'text';
+    }
+    filterCustomMetadata(metadata) {
+        const standardKeys = ['overview', 'goals', 'requirements', 'source_format'];
+        const custom = {};
+        for (const [key, value] of Object.entries(metadata)) {
+            if (!standardKeys.includes(key)) {
+                custom[key] = value;
+            }
+        }
+        return custom;
+    }
+    convertChangesToSteps(changes) {
+        const steps = [];
+        const pathDependencies = new Map();
+        for (let i = 0; i < changes.length; i++) {
+            const change = changes[i];
+            const deps = [];
+            if (change.path) {
+                const previousIndex = pathDependencies.get(change.path);
+                if (previousIndex !== undefined) {
+                    deps.push(`Step ${previousIndex + 1}`);
+                }
+                pathDependencies.set(change.path, i);
+            }
+            steps.push({
+                title: change.description,
+                details: change.path ? `Target: ${change.path}` : '',
+                dependencies: deps,
+            });
+        }
+        return steps;
+    }
+    convertChangesToTasks(changes) {
+        const tasks = [];
+        for (const change of changes) {
+            const task = {
+                description: change.description,
+                completed: false,
+                subtasks: [],
+            };
+            if (change.type === 'file_create' || change.type === 'file_update') {
+                task.subtasks.push({
+                    description: `Edit ${change.path || 'file'}`,
+                    completed: false,
+                });
+                if (this.config.preserveMetadata) {
+                    task.subtasks.push({
+                        description: 'Add file metadata',
+                        completed: false,
+                    });
+                }
+            }
+            if (change.type.startsWith('dependency_')) {
+                task.subtasks.push({
+                    description: 'Update package manifest',
+                    completed: false,
+                });
+                task.subtasks.push({
+                    description: 'Run package manager',
+                    completed: false,
+                });
+            }
+            tasks.push(task);
+        }
+        return tasks;
+    }
+}