@eddacraft/anvil-adapters 0.1.0

package/dist/speckit/import-v2.js

@@ -0,0 +1,361 @@
+/**
+ * SpecKit Import Adapter v2 - Official Format
+ *
+ * Supports official GitHub spec-kit format:
+ * - spec.md: Requirements and user scenarios (WHAT and WHY)
+ * - plan.md: Technical implementation details (HOW)
+ * - tasks.md: Executable task breakdown
+ *
+ * Can import individual files or complete feature directories
+ */
+import { createPlan } from '@eddacraft/anvil-core';
+import { BaseAdapter } from '../common/types.js';
+import { SpecParser } from './parsers/spec-parser.js';
+import { PlanParser } from './parsers/plan-parser.js';
+import { TasksParser } from './parsers/tasks-parser.js';
+export class SpecKitImportAdapterV2 extends BaseAdapter {
+    name = 'speckit-import-v2';
+    version = '2.0.0';
+    supportedFormats = ['speckit', 'spec-kit', 'spec.md', 'plan.md', 'tasks.md'];
+    specParser;
+    planParser;
+    tasksParser;
+    constructor(config = {}) {
+        super(config);
+        this.specParser = new SpecParser();
+        this.planParser = new PlanParser();
+        this.tasksParser = new TasksParser();
+    }
+    async generateSpec(intent, context) {
+        const provenance = {
+            timestamp: new Date().toISOString(),
+            source: 'cli',
+            version: this.version,
+            author: context.author,
+            repository: context.repositoryPath,
+            branch: context.branch,
+            commit: context.commit,
+        };
+        // Generate a simple spec.md file creation change
+        const changes = [
+            {
+                type: 'file_create',
+                path: 'specs/new-feature/spec.md',
+                description: 'Create specification file following spec-kit format',
+                content: this.generateSpecTemplate(intent),
+            },
+        ];
+        const planId = `aps-${Date.now().toString(16).substring(0, 8)}`;
+        return {
+            ...createPlan({
+                id: planId,
+                intent,
+                provenance,
+                changes,
+            }),
+            schema_version: '0.1.0',
+            hash: '0'.repeat(64),
+        };
+    }
+    async validateSpec(spec) {
+        const errors = [];
+        const warnings = [];
+        if (spec.proposed_changes.length === 0) {
+            warnings.push({
+                field: 'proposed_changes',
+                message: 'No changes specified in the plan',
+            });
+        }
+        const issues = [
+            ...errors.map((e) => ({
+                path: e.field,
+                message: e.message,
+                code: 'VALIDATION_ERROR',
+                severity: 'error',
+            })),
+            ...warnings.map((w) => ({
+                path: w.field,
+                message: w.message,
+                code: 'VALIDATION_WARNING',
+                severity: 'warning',
+            })),
+        ];
+        return {
+            valid: errors.length === 0,
+            data: spec,
+            issues: issues.length > 0 ? issues : undefined,
+            summary: errors.length === 0 ? 'Validation passed' : `Found ${errors.length} error(s)`,
+        };
+    }
+    async convertToAPS(spec) {
+        const errors = [];
+        const warnings = [];
+        if (!this.canImport(spec.format)) {
+            return {
+                success: false,
+                errors: [
+                    {
+                        code: 'UNSUPPORTED_FORMAT',
+                        message: `Format '${spec.format}' is not supported by this adapter`,
+                    },
+                ],
+            };
+        }
+        try {
+            const docs = spec.content;
+            // Parse all available documents
+            if (docs.spec?.content) {
+                docs.spec.parsed = this.specParser.parseSpec(docs.spec.content);
+            }
+            if (docs.plan?.content) {
+                docs.plan.parsed = this.planParser.parsePlan(docs.plan.content);
+            }
+            if (docs.tasks?.content) {
+                docs.tasks.parsed = this.tasksParser.parseTasks(docs.tasks.content);
+            }
+            // At minimum, we need spec.md
+            if (!docs.spec?.parsed) {
+                return {
+                    success: false,
+                    errors: [
+                        {
+                            code: 'MISSING_SPEC',
+                            message: 'spec.md content is required',
+                        },
+                    ],
+                };
+            }
+            // Build APS plan from parsed documents
+            const apsResult = this.buildAPSFromDocs(docs, spec.metadata, errors, warnings);
+            if (errors.length > 0) {
+                return { success: false, errors, warnings };
+            }
+            return {
+                success: true,
+                data: apsResult,
+                warnings: warnings.length > 0 ? warnings : undefined,
+            };
+        }
+        catch (error) {
+            errors.push({
+                code: 'CONVERSION_ERROR',
+                message: error instanceof Error ? error.message : 'Unknown conversion error',
+            });
+            return { success: false, errors };
+        }
+    }
+    async convertFromAPS(_spec) {
+        return {
+            success: false,
+            errors: [
+                {
+                    code: 'NOT_IMPLEMENTED',
+                    message: 'Export to SpecKit format is handled by speckit-export adapter',
+                },
+            ],
+        };
+    }
+    buildAPSFromDocs(docs, metadata, errors, warnings) {
+        const parsedSpec = docs.spec.parsed;
+        const parsedPlan = docs.plan?.parsed;
+        const parsedTasks = docs.tasks?.parsed;
+        // Build intent from spec user scenarios and metadata
+        const intent = this.buildIntent(parsedSpec);
+        // Build proposed changes from user scenarios + plan details + tasks
+        const changes = this.buildProposedChanges(parsedSpec, parsedPlan, parsedTasks, warnings);
+        // Build provenance
+        const provenance = {
+            timestamp: metadata?.['timestamp'] || new Date().toISOString(),
+            source: 'cli',
+            version: this.version,
+            author: metadata?.['author'] || parsedSpec.metadata.branch,
+            repository: metadata?.['repository'],
+            branch: parsedSpec.metadata.branch,
+            commit: metadata?.['commit'],
+        };
+        const planId = `aps-${Date.now().toString(16).substring(0, 8)}`;
+        return {
+            ...createPlan({
+                id: planId,
+                intent,
+                provenance,
+                changes,
+            }),
+            schema_version: '0.1.0',
+            hash: '0'.repeat(64),
+            metadata: {
+                source_format: 'speckit-v2',
+                feature: parsedSpec.metadata.feature,
+                // From spec.md
+                userScenarios: parsedSpec.userScenarios,
+                requirements: parsedSpec.requirements,
+                successCriteria: parsedSpec.successCriteria,
+                clarifications: parsedSpec.clarifications,
+                // From plan.md
+                technicalContext: parsedPlan?.technicalContext,
+                constitutionCheck: parsedPlan?.constitutionCheck,
+                projectStructure: parsedPlan?.projectStructure,
+                implementationDetails: parsedPlan?.implementationDetails
+                    ? Object.fromEntries(parsedPlan.implementationDetails)
+                    : undefined,
+                complexityDecisions: parsedPlan?.complexityDecisions,
+                // From tasks.md
+                phases: parsedTasks?.phases,
+                taskDependencies: parsedTasks?.dependencies,
+                implementationStrategies: parsedTasks?.strategies,
+            },
+        };
+    }
+    buildIntent(parsedSpec) {
+        // Build intent from feature name and P1 user scenarios
+        const feature = parsedSpec.metadata.feature || 'Feature';
+        const p1Scenarios = parsedSpec.userScenarios.filter((s) => s.priority === 'P1');
+        if (p1Scenarios.length === 0) {
+            return `Implement ${feature}`;
+        }
+        const scenarioDescriptions = p1Scenarios
+            .map((s) => `${s.asA} wants to ${s.iWantTo} so that ${s.soThat}`)
+            .join('. ');
+        return `${feature}: ${scenarioDescriptions}`.substring(0, 500);
+    }
+    buildProposedChanges(parsedSpec, parsedPlan, parsedTasks, warnings) {
+        const changes = [];
+        // Strategy: Convert user scenarios to proposed changes
+        // Each scenario represents a feature to implement
+        for (const scenario of parsedSpec.userScenarios) {
+            // Create a change for each P1/P2 user scenario
+            if (scenario.priority === 'P1' || scenario.priority === 'P2') {
+                const change = {
+                    type: 'file_create',
+                    path: this.inferPathFromScenario(scenario, parsedPlan),
+                    description: `Implement ${scenario.title}: ${scenario.iWantTo}`,
+                    metadata: {
+                        priority: scenario.priority,
+                        userStory: {
+                            asA: scenario.asA,
+                            iWantTo: scenario.iWantTo,
+                            soThat: scenario.soThat,
+                        },
+                        acceptanceScenarios: scenario.acceptanceScenarios,
+                        edgeCases: scenario.edgeCases,
+                    },
+                };
+                changes.push(change);
+            }
+        }
+        // If we have plan details, add implementation-specific changes
+        if (parsedPlan) {
+            // Add database migrations if mentioned
+            if (parsedPlan.implementationDetails.has('Database Schema')) {
+                changes.push({
+                    type: 'file_create',
+                    path: 'database/migrations/',
+                    description: 'Create database migrations for required tables',
+                    metadata: {
+                        section: 'Database Schema',
+                    },
+                });
+            }
+            // Add API endpoints if mentioned
+            if (parsedPlan.implementationDetails.has('API Endpoints')) {
+                changes.push({
+                    type: 'file_create',
+                    path: this.inferAPIPath(parsedPlan),
+                    description: 'Implement API endpoints',
+                    metadata: {
+                        section: 'API Endpoints',
+                    },
+                });
+            }
+        }
+        // Add dependency installation if we have technical context
+        if (parsedPlan?.technicalContext.dependencies &&
+            parsedPlan.technicalContext.dependencies.length > 0) {
+            changes.push({
+                type: 'dependency_add',
+                path: 'package.json',
+                description: `Install dependencies: ${parsedPlan.technicalContext.dependencies.slice(0, 3).join(', ')}${parsedPlan.technicalContext.dependencies.length > 3 ? '...' : ''}`,
+                metadata: {
+                    dependencies: parsedPlan.technicalContext.dependencies,
+                },
+            });
+        }
+        if (changes.length === 0) {
+            warnings.push({
+                code: 'NO_CHANGES',
+                message: 'No actionable changes could be derived from spec',
+            });
+        }
+        return changes;
+    }
+    inferPathFromScenario(scenario, plan) {
+        const title = scenario.title.toLowerCase().replace(/\s+/g, '-');
+        // Use plan structure if available
+        if (plan?.projectStructure.sourceCode) {
+            // Try to extract common patterns
+            if (plan.projectStructure.sourceCode.includes('src/modules/')) {
+                return `src/modules/${title}/`;
+            }
+            if (plan.projectStructure.sourceCode.includes('src/features/')) {
+                return `src/features/${title}/`;
+            }
+        }
+        return `src/${title}/`;
+    }
+    inferAPIPath(plan) {
+        if (plan.projectStructure.sourceCode?.includes('controllers')) {
+            return 'src/controllers/';
+        }
+        if (plan.projectStructure.sourceCode?.includes('routes')) {
+            return 'src/routes/';
+        }
+        return 'src/api/';
+    }
+    generateSpecTemplate(intent) {
+        return `# Feature: ${intent}
+
+**Branch**: \`feature/xxx-feature-name\`
+**Date**: ${new Date().toISOString().split('T')[0]}
+**Status**: Draft
+
+## User Scenarios & Testing
+
+### P1: [User Scenario Title]
+**As a** [user type]
+**I want to** [action]
+**So that** [benefit]
+
+**Acceptance Scenarios:**
+- [Scenario 1]
+- [Scenario 2]
+
+**Edge Cases:**
+- [Edge case 1]
+- [NEEDS CLARIFICATION: Question?]
+
+## Requirements
+
+### Functional Requirements
+
+**FR-001**: System MUST [requirement]
+**FR-002**: [NEEDS CLARIFICATION: What should happen when...]
+
+### Key Entities
+
+**EntityName**
+- Represents: [What this entity represents]
+- Key Attributes: [attribute1, attribute2]
+- Relationships: [relationships to other entities]
+
+## Success Criteria
+
+### Quantitative Metrics
+- [Metric 1]
+- [Metric 2]
+
+### Qualitative Metrics
+- [Metric 1]
+- [Metric 2]
+`;
+    }
+}

package/dist/speckit/import.d.ts

@@ -0,0 +1,16 @@
+import { type APSPlan } from '@eddacraft/anvil-core';
+import type { AdapterConfig, ConversionResult, ExternalSpec, SpecContext } from '../common/types.js';
+import { BaseAdapter } from '../common/types.js';
+export declare class SpecKitImportAdapter extends BaseAdapter {
+    readonly name = "speckit-import";
+    readonly version = "1.0.0";
+    readonly supportedFormats: readonly ["speckit", "spec.md"];
+    private parser;
+    constructor(config?: AdapterConfig);
+    generateSpec(intent: string, context: SpecContext): Promise<APSPlan>;
+    validateSpec(spec: APSPlan): Promise<import('@eddacraft/anvil-core').ValidationResult>;
+    convertToAPS(spec: ExternalSpec): Promise<ConversionResult<APSPlan>>;
+    convertFromAPS(_spec: APSPlan): Promise<ConversionResult<ExternalSpec>>;
+    private convertChangesToAPS;
+}
+//# sourceMappingURL=import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/speckit/import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAgC,MAAM,uBAAuB,CAAC;AAC/F,OAAO,KAAK,EACV,aAAa,EAEb,gBAAgB,EAEhB,YAAY,EACZ,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAUjD,qBAAa,oBAAqB,SAAQ,WAAW;IACnD,QAAQ,CAAC,IAAI,oBAAoB;IACjC,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,gBAAgB,kCAAmC;IAE5D,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,GAAE,aAAkB;IAKhC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAmCpE,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,uBAAuB,EAAE,gBAAgB,CAAC;IAwDtF,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAoGpE,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAY7E,OAAO,CAAC,mBAAmB;CAsE5B"}

package/dist/speckit/import.js

@@ -0,0 +1,247 @@
+import { createPlan } from '@eddacraft/anvil-core';
+import { BaseAdapter } from '../common/types.js';
+import { SpecKitParser } from './parser.js';
+export class SpecKitImportAdapter extends BaseAdapter {
+    name = 'speckit-import';
+    version = '1.0.0';
+    supportedFormats = ['speckit', 'spec.md'];
+    parser;
+    constructor(config = {}) {
+        super(config);
+        this.parser = new SpecKitParser();
+    }
+    async generateSpec(intent, context) {
+        const provenance = {
+            timestamp: new Date().toISOString(),
+            source: 'cli',
+            version: this.version,
+            author: context.author,
+            repository: context.repositoryPath,
+            branch: context.branch,
+            commit: context.commit,
+        };
+        const changes = [
+            {
+                type: 'file_create',
+                path: 'spec.md',
+                description: 'Create initial specification file',
+                content: `# Specification\n\n## Intent\n\n${intent}\n\n## Overview\n\n[Describe the overall approach]\n\n## Requirements\n\n- [List prerequisites]\n\n## Changes\n\n- [List proposed changes]\n`,
+            },
+        ];
+        const planId = `aps-${Date.now().toString(16).substring(0, 8)}`;
+        const plan = {
+            ...createPlan({
+                id: planId,
+                intent,
+                provenance,
+                changes,
+            }),
+            schema_version: '0.1.0',
+            hash: '0'.repeat(64), // Placeholder hash
+        };
+        return plan;
+    }
+    async validateSpec(spec) {
+        const errors = [];
+        const warnings = [];
+        if (spec.proposed_changes.length === 0) {
+            warnings.push({
+                field: 'proposed_changes',
+                message: 'No changes specified in the plan',
+            });
+        }
+        for (let i = 0; i < spec.proposed_changes.length; i++) {
+            const change = spec.proposed_changes[i];
+            if (!change.description || change.description.length < 10) {
+                warnings.push({
+                    field: `proposed_changes[${i}].description`,
+                    message: 'Change description is too short or missing',
+                });
+            }
+            if (!change.path && change.type !== 'script_execute') {
+                errors.push({
+                    field: `proposed_changes[${i}].path`,
+                    message: `Path is required for change type '${change.type}'`,
+                });
+            }
+        }
+        const issues = [
+            ...errors.map((e) => ({
+                path: e.field,
+                message: e.message,
+                code: 'VALIDATION_ERROR',
+                severity: 'error',
+            })),
+            ...warnings.map((w) => ({
+                path: w.field,
+                message: w.message,
+                code: 'VALIDATION_WARNING',
+                severity: 'warning',
+            })),
+        ];
+        return {
+            valid: errors.length === 0,
+            data: spec,
+            issues: issues.length > 0 ? issues : undefined,
+            summary: errors.length === 0 ? 'Validation passed' : `Found ${errors.length} error(s)`,
+        };
+    }
+    async convertToAPS(spec) {
+        const errors = [];
+        const warnings = [];
+        if (!this.canImport(spec.format)) {
+            return {
+                success: false,
+                errors: [
+                    {
+                        code: 'UNSUPPORTED_FORMAT',
+                        message: `Format '${spec.format}' is not supported by this adapter`,
+                    },
+                ],
+            };
+        }
+        try {
+            const specKitSpec = spec.content;
+            if (!specKitSpec.specContent) {
+                errors.push({
+                    code: 'MISSING_SPEC_CONTENT',
+                    message: 'spec.md content is required',
+                });
+                return { success: false, errors };
+            }
+            const parsed = this.parser.parseSpecMarkdown(specKitSpec.specContent);
+            if (!parsed.intent && !parsed.overview) {
+                errors.push({
+                    code: 'MISSING_INTENT',
+                    message: 'No intent or overview section found in spec.md',
+                });
+            }
+            else if (!parsed.intent) {
+                warnings.push({
+                    code: 'MISSING_INTENT',
+                    message: 'No intent section found, using overview as fallback',
+                });
+            }
+            const changes = this.convertChangesToAPS(parsed.changes || [], errors, warnings);
+            if (errors.length > 0) {
+                return { success: false, errors, warnings };
+            }
+            const intent = parsed.intent || parsed.overview || 'Specification from SpecKit';
+            const provenance = {
+                timestamp: spec.metadata?.['timestamp'] || new Date().toISOString(),
+                source: 'cli',
+                version: this.version,
+                author: spec.metadata?.['author'],
+                repository: spec.metadata?.['repository'],
+                branch: spec.metadata?.['branch'],
+                commit: spec.metadata?.['commit'],
+            };
+            const planId = `aps-${Date.now().toString(16).substring(0, 8)}`;
+            try {
+                const plan = {
+                    ...createPlan({
+                        id: planId,
+                        intent: intent.substring(0, 500),
+                        provenance,
+                        changes,
+                    }),
+                    schema_version: '0.1.0',
+                    hash: '0'.repeat(64), // Placeholder hash
+                    metadata: {
+                        ...parsed.metadata,
+                        source_format: 'speckit',
+                        goals: parsed.goals,
+                        requirements: parsed.requirements,
+                        overview: parsed.overview,
+                    },
+                };
+                return {
+                    success: true,
+                    data: plan,
+                    warnings: warnings.length > 0 ? warnings : undefined,
+                };
+            }
+            catch (error) {
+                errors.push({
+                    code: 'APS_CREATION_FAILED',
+                    message: error instanceof Error ? error.message : 'Failed to create APS plan',
+                });
+                return { success: false, errors };
+            }
+        }
+        catch (error) {
+            errors.push({
+                code: 'CONVERSION_ERROR',
+                message: error instanceof Error ? error.message : 'Unknown conversion error',
+            });
+            return { success: false, errors };
+        }
+    }
+    async convertFromAPS(_spec) {
+        return {
+            success: false,
+            errors: [
+                {
+                    code: 'NOT_IMPLEMENTED',
+                    message: 'Export to SpecKit format is handled by speckit-export adapter',
+                },
+            ],
+        };
+    }
+    convertChangesToAPS(changes, errors, warnings) {
+        const apsChanges = [];
+        for (let i = 0; i < changes.length; i++) {
+            const change = changes[i];
+            if (!change.description) {
+                warnings.push({
+                    code: 'EMPTY_DESCRIPTION',
+                    message: `Change ${i + 1} has no description`,
+                    path: `changes[${i}]`,
+                });
+                continue;
+            }
+            const validTypes = [
+                'file_create',
+                'file_update',
+                'file_delete',
+                'config_update',
+                'dependency_add',
+                'dependency_remove',
+                'dependency_update',
+                'script_execute',
+            ];
+            if (!validTypes.includes(change.type)) {
+                warnings.push({
+                    code: 'UNKNOWN_CHANGE_TYPE',
+                    message: `Unknown change type '${change.type}', defaulting to 'script_execute'`,
+                    path: `changes[${i}].type`,
+                });
+                change.type = 'script_execute';
+            }
+            const apsChange = {
+                type: change.type,
+                path: change.path || '',
+                description: change.description,
+            };
+            if (change.content) {
+                apsChange.content = change.content;
+            }
+            if (!apsChange.path && apsChange.type !== 'script_execute') {
+                warnings.push({
+                    code: 'MISSING_PATH',
+                    message: `Path not specified for ${apsChange.type}, using placeholder`,
+                    path: `changes[${i}].path`,
+                });
+                apsChange.path = '<path-to-be-specified>';
+            }
+            apsChanges.push(apsChange);
+        }
+        if (apsChanges.length === 0) {
+            warnings.push({
+                code: 'NO_CHANGES',
+                message: 'No valid changes found in specification',
+            });
+        }
+        return apsChanges;
+    }
+}

package/dist/speckit/index.d.ts

@@ -0,0 +1,5 @@
+export { SpecKitImportAdapter } from './import.js';
+export { SpecKitExportAdapter } from './export.js';
+export { SpecKitParser } from './parser.js';
+export { SpecKitFormatAdapter, createSpecKitAdapter } from './format-adapter.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/speckit/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/speckit/index.js

@@ -0,0 +1,4 @@
+export { SpecKitImportAdapter } from './import.js';
+export { SpecKitExportAdapter } from './export.js';
+export { SpecKitParser } from './parser.js';
+export { SpecKitFormatAdapter, createSpecKitAdapter } from './format-adapter.js';

package/dist/speckit/parser.d.ts

@@ -0,0 +1,28 @@
+interface ParsedSpecKit {
+    intent?: string;
+    overview?: string;
+    goals?: string[];
+    requirements?: string[];
+    changes?: Array<{
+        type: string;
+        description: string;
+        path?: string;
+        content?: string;
+    }>;
+    metadata?: Record<string, unknown>;
+}
+export declare class SpecKitParser {
+    private static readonly SPEC_SECTIONS;
+    /** Maximum input size for SpecKit parsing (2MB) */
+    private static readonly MAX_INPUT_SIZE;
+    parseSpecMarkdown(content: string): ParsedSpecKit;
+    private parseMarkdownSections;
+    private extractSectionData;
+    private extractParagraphText;
+    private parseListItems;
+    private parseChanges;
+    private parseChangeSection;
+    private parseChangeFromListItem;
+}
+export {};
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/speckit/parser.ts"],"names":[],"mappings":"AASA,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAeD,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAM1B;IAEX,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAEzD,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa;IAgBjD,OAAO,CAAC,qBAAqB;IAgD7B,OAAO,CAAC,kBAAkB;IA6C1B,OAAO,CAAC,oBAAoB;IA0B5B,OAAO,CAAC,cAAc;IA0BtB,OAAO,CAAC,YAAY;IAsDpB,OAAO,CAAC,kBAAkB;IA+C1B,OAAO,CAAC,uBAAuB;CAwChC"}