@eddacraft/anvil-adapters 0.1.0

package/dist/speckit/format-adapter.d.ts

@@ -0,0 +1,104 @@
+/**
+ * SpecKit Format Adapter
+ *
+ * FormatAdapter implementation for GitHub spec-kit format.
+ * Handles simple SpecKit specification documents with Intent, Overview, Goals,
+ * Requirements, and Changes sections.
+ *
+ * Uses SpecKitParser to parse markdown with ## sections and convert to/from APS format.
+ */
+import { type APSPlan, type ValidationResult } from '@eddacraft/anvil-core';
+import { BaseFormatAdapter, type AdapterMetadata, type DetectionResult, type ParseResult, type SerializeResult, type ParseContext, type AdapterOptions, type PathDetectionHint } from '../base/types.js';
+/**
+ * SpecKit FormatAdapter implementation
+ *
+ * Converts between SpecKit format documents and APS plans.
+ */
+export declare class SpecKitFormatAdapter extends BaseFormatAdapter {
+    readonly metadata: AdapterMetadata;
+    private parser;
+    constructor(options?: AdapterOptions);
+    /**
+     * Detect if content is SpecKit format
+     *
+     * Uses confidence scoring based on multiple indicators:
+     * - Specification header (20 points)
+     * - Intent section (15 points)
+     * - Overview section (10 points)
+     * - Goals section (10 points)
+     * - Requirements section (10 points)
+     * - Changes section (20 points)
+     * - Files to Create/Update sections (10 points)
+     * - Code blocks (5 points)
+     *
+     * @param content - Document content to analyze
+     * @returns Detection result with confidence score
+     */
+    detect(content: string): DetectionResult;
+    /**
+     * Detect with file path hints for improved accuracy
+     *
+     * Uses sibling file information (e.g., AGENTS.md) and content
+     * namespace patterns (e.g., `speckit.*`) to boost detection.
+     *
+     * @param content - Document content to analyze
+     * @param hint - Path and directory information
+     * @returns Detection result with confidence score
+     */
+    detectWithPath(content: string, hint: PathDetectionHint): DetectionResult;
+    /**
+     * Parse SpecKit content to APS plan
+     *
+     * @param content - SpecKit markdown content
+     * @param context - Parse context for provenance
+     * @param options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    parse(content: string, context?: ParseContext, _options?: AdapterOptions): Promise<ParseResult>;
+    /**
+     * Infer APS change type from SpecKit change type
+     */
+    private inferChangeType;
+    /**
+     * Infer file path from change description
+     */
+    private inferPathFromDescription;
+    /**
+     * Serialize APS plan to SpecKit format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Adapter options
+     * @returns Serialize result with SpecKit markdown
+     */
+    serialize(plan: APSPlan, _options?: AdapterOptions): Promise<SerializeResult>;
+    /**
+     * Validate SpecKit content
+     *
+     * Checks for required SpecKit elements without full conversion.
+     *
+     * @param content - SpecKit content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    validate(content: string, _options?: AdapterOptions): Promise<ValidationResult>;
+    /**
+     * Analyze content for SpecKit indicators
+     */
+    private analyzeContent;
+    /**
+     * Calculate confidence score
+     */
+    private calculateConfidence;
+    /**
+     * Build detection reason message
+     */
+    private buildDetectionReason;
+}
+/**
+ * Create a new SpecKit format adapter instance
+ *
+ * @param options - Adapter options
+ * @returns SpecKit adapter instance
+ */
+export declare function createSpecKitAdapter(options?: AdapterOptions): SpecKitFormatAdapter;
+//# sourceMappingURL=format-adapter.d.ts.map

package/dist/speckit/format-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-adapter.d.ts","sourceRoot":"","sources":["../../src/speckit/format-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAEL,KAAK,OAAO,EACZ,KAAK,gBAAgB,EAItB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAwB1B;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,iBAAiB;IACzD,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAOhC;IAEF,OAAO,CAAC,MAAM,CAAgB;gBAElB,OAAO,CAAC,EAAE,cAAc;IAKpC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe;IAUxC;;;;;;;;;OASG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,eAAe;IAQzE;;;;;;;OAOG;IACG,KAAK,CACT,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,WAAW,CAAC;IA+EvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAehC;;;;;;OAMG;IACG,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC;IAsInF;;;;;;;;OAQG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8DrF;;OAEG;IACH,OAAO,CAAC,cAAc;IA4BtB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA8D3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;CAoC7B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,oBAAoB,CAEnF"}

package/dist/speckit/format-adapter.js

@@ -0,0 +1,488 @@
+/**
+ * SpecKit Format Adapter
+ *
+ * FormatAdapter implementation for GitHub spec-kit format.
+ * Handles simple SpecKit specification documents with Intent, Overview, Goals,
+ * Requirements, and Changes sections.
+ *
+ * Uses SpecKitParser to parse markdown with ## sections and convert to/from APS format.
+ */
+import { generateHash, createPlan, validateRelativePath, } from '@eddacraft/anvil-core';
+import { BaseFormatAdapter, } from '../base/types.js';
+import { createDetection, generateDeterministicPlanId } from '../base/utils.js';
+import { SpecKitParser } from './parser.js';
+/**
+ * SpecKit FormatAdapter implementation
+ *
+ * Converts between SpecKit format documents and APS plans.
+ */
+export class SpecKitFormatAdapter extends BaseFormatAdapter {
+    metadata = {
+        name: 'speckit',
+        version: '2.0.0',
+        displayName: 'GitHub SpecKit',
+        description: 'GitHub spec-kit format adapter (spec.md, plan.md, tasks.md)',
+        formats: ['speckit', 'spec-kit', 'spec.md', 'plan.md', 'tasks.md'],
+        extensions: ['.md'],
+    };
+    parser;
+    constructor(options) {
+        super(options);
+        this.parser = new SpecKitParser();
+    }
+    /**
+     * Detect if content is SpecKit format
+     *
+     * Uses confidence scoring based on multiple indicators:
+     * - Specification header (20 points)
+     * - Intent section (15 points)
+     * - Overview section (10 points)
+     * - Goals section (10 points)
+     * - Requirements section (10 points)
+     * - Changes section (20 points)
+     * - Files to Create/Update sections (10 points)
+     * - Code blocks (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
+        // Lower threshold than BMAD to accommodate minimal SpecKit documents
+        return createDetection(confidence >= 50, confidence, reason);
+    }
+    /**
+     * Detect with file path hints for improved accuracy
+     *
+     * Uses sibling file information (e.g., AGENTS.md) and content
+     * namespace patterns (e.g., `speckit.*`) to boost detection.
+     *
+     * @param content - Document content to analyze
+     * @param hint - Path and directory information
+     * @returns Detection result with confidence score
+     */
+    detectWithPath(content, hint) {
+        const indicators = this.analyzeContent(content, hint);
+        const confidence = this.calculateConfidence(indicators);
+        const reason = this.buildDetectionReason(indicators);
+        return createDetection(confidence >= 50, confidence, reason);
+    }
+    /**
+     * Parse SpecKit content to APS plan
+     *
+     * @param content - SpecKit markdown content
+     * @param context - Parse context for provenance
+     * @param options - Adapter options
+     * @returns Parse result with APS plan
+     */
+    async parse(content, context, _options) {
+        try {
+            // Parse SpecKit markdown using SpecKitParser
+            const parsed = this.parser.parseSpecMarkdown(content);
+            // Build intent from parsed content
+            const intent = parsed.intent || 'Implement Feature';
+            // Build proposed changes from parsed changes
+            const changes = [];
+            if (parsed.changes && parsed.changes.length > 0) {
+                for (const change of parsed.changes) {
+                    const changeType = this.inferChangeType(change.type);
+                    const rawPath = change.path || this.inferPathFromDescription(change.description);
+                    let safePath;
+                    try {
+                        safePath = validateRelativePath(rawPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    changes.push({
+                        type: changeType,
+                        path: safePath,
+                        description: change.description,
+                        content: change.content,
+                    });
+                }
+            }
+            // Build provenance
+            const provenance = {
+                timestamp: context?.timestamp || new Date().toISOString(),
+                source: 'cli',
+                version: this.metadata.version,
+                author: context?.author,
+                repository: context?.repositoryPath,
+                branch: context?.branch,
+                commit: context?.commit,
+            };
+            const planId = context?.planId ?? generateDeterministicPlanId(content);
+            // Create APS plan
+            const plan = {
+                ...createPlan({
+                    id: planId,
+                    intent,
+                    provenance,
+                    changes,
+                }),
+                schema_version: '0.1.0',
+                hash: '0'.repeat(64), // Temporary, will be replaced
+                metadata: {
+                    source_format: 'speckit',
+                    overview: parsed.overview,
+                    goals: parsed.goals,
+                    requirements: parsed.requirements,
+                    ...parsed.metadata,
+                },
+            };
+            // Generate hash for the plan
+            const planWithHash = {
+                ...plan,
+                hash: generateHash(plan),
+            };
+            return this.createParseSuccess(planWithHash);
+        }
+        catch (error) {
+            return this.createParseError([
+                {
+                    code: 'PARSE_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to parse SpecKit content',
+                    details: error,
+                },
+            ]);
+        }
+    }
+    /**
+     * Infer APS change type from SpecKit change type
+     */
+    inferChangeType(type) {
+        const typeLower = type.toLowerCase();
+        if (typeLower.includes('create'))
+            return 'file_create';
+        if (typeLower.includes('update') || typeLower.includes('modify'))
+            return 'file_update';
+        if (typeLower.includes('delete') || typeLower.includes('remove'))
+            return 'file_delete';
+        return 'file_update'; // Default to update
+    }
+    /**
+     * Infer file path from change description
+     */
+    inferPathFromDescription(description) {
+        // Try to extract path from common patterns like "at path/to/file" or "`path/to/file`"
+        const pathMatch = description.match(/at\s+`([^`]+)`/) ||
+            description.match(/at\s+(\S+\.\w+)/) ||
+            description.match(/`([^`]+\.\w+)`/);
+        if (pathMatch) {
+            return pathMatch[1];
+        }
+        // Fallback: generate a generic path
+        return 'src/generated-file.ts';
+    }
+    /**
+     * Serialize APS plan to SpecKit format
+     *
+     * @param plan - APS plan to serialize
+     * @param options - Adapter options
+     * @returns Serialize result with SpecKit markdown
+     */
+    async serialize(plan, _options) {
+        try {
+            const sections = [];
+            // Header
+            sections.push('# Specification');
+            sections.push('');
+            // Intent section
+            sections.push('## Intent');
+            sections.push('');
+            sections.push(plan.intent);
+            sections.push('');
+            // Overview section (if available in metadata)
+            const overview = plan.metadata?.['overview'];
+            if (overview) {
+                sections.push('## Overview');
+                sections.push('');
+                sections.push(overview);
+                sections.push('');
+            }
+            // Goals section (if available in metadata)
+            const goals = plan.metadata?.['goals'];
+            if (goals && Array.isArray(goals)) {
+                sections.push('## Goals');
+                sections.push('');
+                for (const goal of goals) {
+                    sections.push(`- ${goal}`);
+                }
+                sections.push('');
+            }
+            // Requirements section (if available in metadata)
+            const requirements = plan.metadata?.['requirements'];
+            if (requirements && Array.isArray(requirements)) {
+                sections.push('## Requirements');
+                sections.push('');
+                for (const req of requirements) {
+                    sections.push(`- ${req}`);
+                }
+                sections.push('');
+            }
+            // Changes section
+            if (plan.proposed_changes.length > 0) {
+                sections.push('## Changes');
+                sections.push('');
+                // Group changes by type
+                const fileCreates = plan.proposed_changes.filter((c) => c.type === 'file_create');
+                const fileUpdates = plan.proposed_changes.filter((c) => c.type === 'file_update');
+                const fileDeletes = plan.proposed_changes.filter((c) => c.type === 'file_delete');
+                // Files to Create
+                if (fileCreates.length > 0) {
+                    sections.push('### Files to Create');
+                    sections.push('');
+                    for (const change of fileCreates) {
+                        sections.push(`#### Create ${change.path}`);
+                        sections.push('');
+                        sections.push(change.description || 'No description provided');
+                        sections.push('');
+                        if (change.content) {
+                            sections.push('```typescript');
+                            sections.push(change.content);
+                            sections.push('```');
+                            sections.push('');
+                        }
+                    }
+                }
+                // Files to Update
+                if (fileUpdates.length > 0) {
+                    sections.push('### Files to Update');
+                    sections.push('');
+                    for (const change of fileUpdates) {
+                        sections.push(`#### Update ${change.path}`);
+                        sections.push('');
+                        sections.push(change.description || 'No description provided');
+                        sections.push('');
+                        if (change.content) {
+                            sections.push('```typescript');
+                            sections.push(change.content);
+                            sections.push('```');
+                            sections.push('');
+                        }
+                    }
+                }
+                // Files to Delete
+                if (fileDeletes.length > 0) {
+                    sections.push('### Files to Delete');
+                    sections.push('');
+                    for (const change of fileDeletes) {
+                        sections.push(`#### Delete ${change.path}`);
+                        sections.push('');
+                        sections.push(change.description || 'No description provided');
+                        sections.push('');
+                    }
+                }
+            }
+            // Metadata section (if additional metadata exists)
+            const metadataKeys = Object.keys(plan.metadata || {}).filter((k) => !['source_format', 'overview', 'goals', 'requirements'].includes(k));
+            if (metadataKeys.length > 0) {
+                sections.push('## Metadata');
+                sections.push('');
+                sections.push('```json');
+                const filteredMetadata = {};
+                for (const key of metadataKeys) {
+                    filteredMetadata[key] = plan.metadata?.[key];
+                }
+                sections.push(JSON.stringify(filteredMetadata, null, 2));
+                sections.push('```');
+                sections.push('');
+            }
+            const content = sections.join('\n');
+            return this.createSerializeSuccess(content);
+        }
+        catch (error) {
+            return this.createSerializeError([
+                {
+                    code: 'SERIALIZE_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to serialize to SpecKit format',
+                    details: error,
+                },
+            ]);
+        }
+    }
+    /**
+     * Validate SpecKit content
+     *
+     * Checks for required SpecKit elements without full conversion.
+     *
+     * @param content - SpecKit content to validate
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    async validate(content, _options) {
+        const issues = [];
+        // Check for minimum content length
+        if (content.trim().length < 100) {
+            issues.push({
+                code: 'CONTENT_TOO_SHORT',
+                path: 'content',
+                message: 'Content is too short to be a valid SpecKit document',
+                severity: 'error',
+            });
+        }
+        // Analyze content for SpecKit indicators
+        const indicators = this.analyzeContent(content);
+        const confidence = this.calculateConfidence(indicators);
+        // Low confidence suggests invalid SpecKit format
+        if (confidence < 50) {
+            issues.push({
+                code: 'LOW_CONFIDENCE',
+                path: 'content',
+                message: `Content does not appear to be a valid SpecKit document (confidence: ${confidence}%)`,
+                severity: 'error',
+            });
+        }
+        // Check for required sections
+        if (!indicators.hasSpecificationHeader && !indicators.hasChangesSection) {
+            issues.push({
+                code: 'MISSING_REQUIRED_SECTIONS',
+                path: 'content',
+                message: 'Missing required sections (Specification header or Changes section)',
+                severity: 'error',
+            });
+        }
+        // Warn if missing recommended sections
+        if (!indicators.hasIntentSection) {
+            issues.push({
+                code: 'MISSING_INTENT',
+                path: 'content',
+                message: 'Missing recommended Intent section',
+                severity: 'warning',
+            });
+        }
+        return {
+            valid: issues.filter((i) => i.severity === 'error').length === 0,
+            issues: issues.length > 0 ? issues : undefined,
+            summary: issues.length === 0
+                ? 'SpecKit document is valid'
+                : `Found ${issues.length} validation issue${issues.length > 1 ? 's' : ''}`,
+        };
+    }
+    /**
+     * Analyze content for SpecKit indicators
+     */
+    analyzeContent(content, hint) {
+        const lowerContent = content.toLowerCase();
+        // Detect speckit.* namespace commands (e.g., /speckit.clarify, /speckit.analyze)
+        const hasSpeckitNamespace = /\b\/?speckit\.\w+\b/i.test(content);
+        // Check for AGENTS.md sibling
+        const hasAgentsMdSibling = hint?.siblingFiles?.some((f) => f.toLowerCase() === 'agents.md') ?? false;
+        return {
+            hasSpecificationHeader: /^#\s+(specification|spec)\s*$/im.test(content),
+            hasIntentSection: /^##\s+intent\s*$/im.test(content),
+            hasOverviewSection: /^##\s+overview\s*$/im.test(content),
+            hasGoalsSection: /^##\s+goals?\s*$/im.test(content),
+            hasRequirementsSection: /^##\s+requirements?\s*$/im.test(content),
+            hasChangesSection: /^##\s+changes?\s*$/im.test(content),
+            hasFilesToCreateSection: lowerContent.includes('files to create') || lowerContent.includes('create file'),
+            hasFilesToUpdateSection: lowerContent.includes('files to update') || lowerContent.includes('update file'),
+            hasCodeBlocks: /```[\s\S]*?```/.test(content),
+            sectionCount: (content.match(/^##\s+/gim) || []).length,
+            hasSpeckitNamespace,
+            hasAgentsMdSibling,
+        };
+    }
+    /**
+     * Calculate confidence score
+     */
+    calculateConfidence(indicators) {
+        let score = 0;
+        // Specification header (20 points)
+        if (indicators.hasSpecificationHeader) {
+            score += 20;
+        }
+        // Intent section (15 points)
+        if (indicators.hasIntentSection) {
+            score += 15;
+        }
+        // Overview section (10 points)
+        if (indicators.hasOverviewSection) {
+            score += 10;
+        }
+        // Goals section (10 points)
+        if (indicators.hasGoalsSection) {
+            score += 10;
+        }
+        // Requirements section (10 points)
+        if (indicators.hasRequirementsSection) {
+            score += 10;
+        }
+        // Changes section (20 points)
+        if (indicators.hasChangesSection) {
+            score += 20;
+        }
+        // Files to Create/Update sections (10 points)
+        if (indicators.hasFilesToCreateSection || indicators.hasFilesToUpdateSection) {
+            score += 10;
+        }
+        // Code blocks (5 points)
+        if (indicators.hasCodeBlocks) {
+            score += 5;
+        }
+        // speckit.* namespace commands (10 points)
+        if (indicators.hasSpeckitNamespace) {
+            score += 10;
+        }
+        // AGENTS.md sibling (15 points)
+        if (indicators.hasAgentsMdSibling) {
+            score += 15;
+        }
+        // Bonus: If has both Specification header AND Intent section, ensure at least 50% confidence
+        // This accommodates minimal but valid SpecKit documents
+        if (indicators.hasSpecificationHeader && indicators.hasIntentSection && score < 50) {
+            score = 50;
+        }
+        return Math.min(100, score);
+    }
+    /**
+     * Build detection reason message
+     */
+    buildDetectionReason(indicators) {
+        const reasons = [];
+        if (indicators.hasSpecificationHeader) {
+            reasons.push('specification-header');
+        }
+        if (indicators.hasIntentSection) {
+            reasons.push('intent-section');
+        }
+        if (indicators.hasGoalsSection) {
+            reasons.push('goals-section');
+        }
+        if (indicators.hasRequirementsSection) {
+            reasons.push('requirements-section');
+        }
+        if (indicators.hasChangesSection) {
+            reasons.push('changes-section');
+        }
+        if (indicators.hasFilesToCreateSection || indicators.hasFilesToUpdateSection) {
+            reasons.push('file-changes');
+        }
+        if (indicators.hasCodeBlocks) {
+            reasons.push('code-blocks');
+        }
+        if (indicators.hasSpeckitNamespace) {
+            reasons.push('speckit-namespace');
+        }
+        if (indicators.hasAgentsMdSibling) {
+            reasons.push('agents-md');
+        }
+        if (indicators.sectionCount >= 3) {
+            reasons.push(`${indicators.sectionCount} sections`);
+        }
+        return reasons.length > 0 ? reasons.join(', ') : 'no strong indicators';
+    }
+}
+/**
+ * Create a new SpecKit format adapter instance
+ *
+ * @param options - Adapter options
+ * @returns SpecKit adapter instance
+ */
+export function createSpecKitAdapter(options) {
+    return new SpecKitFormatAdapter(options);
+}

package/dist/speckit/import-v2.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 { 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 SpecKitImportAdapterV2 extends BaseAdapter {
+    readonly name = "speckit-import-v2";
+    readonly version = "2.0.0";
+    readonly supportedFormats: readonly ["speckit", "spec-kit", "spec.md", "plan.md", "tasks.md"];
+    private specParser;
+    private planParser;
+    private tasksParser;
+    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 buildAPSFromDocs;
+    private buildIntent;
+    private buildProposedChanges;
+    private inferPathFromScenario;
+    private inferAPIPath;
+    private generateSpecTemplate;
+}
+//# sourceMappingURL=import-v2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import-v2.d.ts","sourceRoot":"","sources":["../../src/speckit/import-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,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;AAqBjD,qBAAa,sBAAuB,SAAQ,WAAW;IACrD,QAAQ,CAAC,IAAI,uBAAuB;IACpC,QAAQ,CAAC,OAAO,WAAW;IAC3B,QAAQ,CAAC,gBAAgB,qEAAsE;IAE/F,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,WAAW,CAAc;gBAErB,MAAM,GAAE,aAAkB;IAOhC,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;IAuCtF,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAgEpE,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAY7E,OAAO,CAAC,gBAAgB;IA8DxB,OAAO,CAAC,WAAW;IAgBnB,OAAO,CAAC,oBAAoB;IAqF5B,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,oBAAoB;CA+C7B"}