@lusipad/pmspec 1.0.0

package/dist/core/importers.js

@@ -0,0 +1,715 @@
+/**
+ * External Tool Importers Module
+ *
+ * Provides import functionality from external project management tools:
+ * - Jira: Epic → Category, Story/Task → Feature
+ * - Linear: Project → Epic, Issue → Feature
+ * - GitHub Issues: Milestone → Milestone, Issue → Feature, Labels → Skills/Tags
+ *
+ * Run `node setup-importers.js` from project root to extract this into
+ * separate files under src/importers/ directory.
+ */
+import { z } from 'zod';
+import { readFile } from 'fs/promises';
+import { CSVHandler } from '../utils/csv-handler.js';
+export const ImportOptionsSchema = z.object({
+    file: z.string().optional(),
+    content: z.string().optional(),
+    dryRun: z.boolean().default(false),
+    merge: z.boolean().default(false),
+    outputFile: z.string().default('features.csv'),
+});
+// ============================================================================
+// Jira Types
+// ============================================================================
+export const JiraIssueSchema = z.object({
+    key: z.string(),
+    fields: z.object({
+        summary: z.string(),
+        description: z.string().nullable().optional(),
+        issuetype: z.object({ name: z.string() }),
+        status: z.object({ name: z.string() }),
+        priority: z.object({ name: z.string() }).optional(),
+        assignee: z.object({ displayName: z.string() }).nullable().optional(),
+        labels: z.array(z.string()).default([]),
+        timeoriginalestimate: z.number().nullable().optional(),
+        created: z.string().optional(),
+        duedate: z.string().nullable().optional(),
+        parent: z.object({
+            key: z.string(),
+            fields: z.object({
+                summary: z.string(),
+                issuetype: z.object({ name: z.string() }),
+            }),
+        }).optional(),
+        customfield_10014: z.string().nullable().optional(),
+    }),
+});
+export const JiraExportSchema = z.object({ issues: z.array(JiraIssueSchema) });
+// ============================================================================
+// Linear Types
+// ============================================================================
+export const LinearIssueSchema = z.object({
+    id: z.string(),
+    identifier: z.string(),
+    title: z.string(),
+    description: z.string().nullable().optional(),
+    state: z.object({ name: z.string(), type: z.string() }),
+    priority: z.number(),
+    priorityLabel: z.string(),
+    estimate: z.number().nullable().optional(),
+    assignee: z.object({ name: z.string() }).nullable().optional(),
+    labels: z.object({ nodes: z.array(z.object({ name: z.string() })) }).optional(),
+    createdAt: z.string().optional(),
+    dueDate: z.string().nullable().optional(),
+    project: z.object({
+        id: z.string(),
+        name: z.string(),
+        description: z.string().nullable().optional(),
+    }).nullable().optional(),
+});
+export const LinearExportSchema = z.object({
+    issues: z.array(LinearIssueSchema),
+    projects: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        description: z.string().nullable().optional(),
+    })).optional(),
+});
+// ============================================================================
+// GitHub Types
+// ============================================================================
+export const GitHubIssueSchema = z.object({
+    number: z.number(),
+    title: z.string(),
+    body: z.string().nullable().optional(),
+    state: z.enum(['open', 'closed']),
+    labels: z.array(z.object({ name: z.string() })).default([]),
+    assignee: z.object({ login: z.string() }).nullable().optional(),
+    assignees: z.array(z.object({ login: z.string() })).optional(),
+    milestone: z.object({
+        number: z.number(),
+        title: z.string(),
+        description: z.string().nullable().optional(),
+        due_on: z.string().nullable().optional(),
+    }).nullable().optional(),
+    created_at: z.string().optional(),
+});
+export const GitHubExportSchema = z.object({
+    issues: z.array(GitHubIssueSchema),
+    milestones: z.array(z.object({
+        number: z.number(),
+        title: z.string(),
+        description: z.string().nullable().optional(),
+        due_on: z.string().nullable().optional(),
+    })).optional(),
+});
+// ============================================================================
+// Base Importer
+// ============================================================================
+class BaseImporter {
+    async getContent(options) {
+        if (options.content)
+            return options.content;
+        if (options.file)
+            return await readFile(options.file, 'utf-8');
+        throw new Error('Either file path or content must be provided');
+    }
+    parseJSON(content) {
+        try {
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON format: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    createEmptyResult() {
+        return {
+            success: false,
+            source: this.source,
+            features: [],
+            epics: [],
+            milestones: [],
+            errors: [],
+            warnings: [],
+            stats: { totalItems: 0, featuresImported: 0, epicsImported: 0, milestonesImported: 0, skipped: 0, errors: 0 },
+        };
+    }
+    generateFeatureId(prefix, index) {
+        return `${prefix}-${String(index).padStart(3, '0')}`;
+    }
+    mapPriority(priority) {
+        const normalized = priority.toLowerCase();
+        if (['critical', 'blocker', 'highest', 'urgent', '1'].includes(normalized))
+            return 'critical';
+        if (['high', '2'].includes(normalized))
+            return 'high';
+        if (['low', 'lowest', 'trivial', '4', '5'].includes(normalized))
+            return 'low';
+        return 'medium';
+    }
+    mapStatus(status) {
+        const normalized = status.toLowerCase();
+        if (['done', 'closed', 'completed', 'resolved', 'finished'].includes(normalized))
+            return 'done';
+        if (['in progress', 'in-progress', 'inprogress', 'started', 'active', 'working'].includes(normalized))
+            return 'in-progress';
+        if (['blocked', 'on hold', 'waiting', 'pending'].includes(normalized))
+            return 'blocked';
+        return 'todo';
+    }
+    formatDate(date) {
+        if (!date)
+            return undefined;
+        try {
+            return new Date(date).toISOString().split('T')[0];
+        }
+        catch {
+            return undefined;
+        }
+    }
+    convertToHours(seconds) {
+        if (!seconds)
+            return 8;
+        return Math.ceil(seconds / 3600);
+    }
+    sanitizeId(name) {
+        return name.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, '-').replace(/^-|-$/g, '').substring(0, 50);
+    }
+    async preview(options) {
+        return this.import({ ...options, dryRun: true });
+    }
+    async writeFeatures(features, outputFile, merge) {
+        if (merge) {
+            try {
+                const existingFeatures = await CSVHandler.readFeatures(outputFile);
+                const mergedFeatures = [...existingFeatures];
+                for (const feature of features) {
+                    const existingIndex = mergedFeatures.findIndex(f => f.id === feature.id);
+                    if (existingIndex >= 0)
+                        mergedFeatures[existingIndex] = feature;
+                    else
+                        mergedFeatures.push(feature);
+                }
+                await CSVHandler.writeFeatures(outputFile, mergedFeatures);
+            }
+            catch {
+                await CSVHandler.writeFeatures(outputFile, features);
+            }
+        }
+        else {
+            await CSVHandler.writeFeatures(outputFile, features);
+        }
+    }
+}
+// ============================================================================
+// Jira Importer
+// ============================================================================
+export class JiraImporter extends BaseImporter {
+    name = 'Jira Importer';
+    source = 'jira';
+    description = 'Import issues from Jira JSON export file';
+    async validate(content) {
+        const errors = [];
+        try {
+            const data = this.parseJSON(content);
+            const result = JiraExportSchema.safeParse(data);
+            if (!result.success) {
+                errors.push('Invalid Jira export format');
+                result.error.issues.forEach(err => errors.push(`${err.path.join('.')}: ${err.message}`));
+                return { valid: false, errors };
+            }
+            if (result.data.issues.length === 0) {
+                errors.push('No issues found in export');
+                return { valid: false, errors };
+            }
+            return { valid: true, errors: [] };
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : 'Unknown validation error');
+            return { valid: false, errors };
+        }
+    }
+    async import(options) {
+        const result = this.createEmptyResult();
+        try {
+            const content = await this.getContent(options);
+            const parseResult = JiraExportSchema.safeParse(this.parseJSON(content));
+            if (!parseResult.success) {
+                result.errors.push({ message: 'Invalid Jira export format' });
+                return result;
+            }
+            const jiraData = parseResult.data;
+            result.stats.totalItems = jiraData.issues.length;
+            const epicsMap = this.extractEpics(jiraData.issues);
+            result.epics = Array.from(epicsMap.values());
+            result.stats.epicsImported = result.epics.length;
+            let featureIndex = 1;
+            for (const issue of jiraData.issues) {
+                try {
+                    if (issue.fields.issuetype.name.toLowerCase() === 'epic')
+                        continue;
+                    const feature = this.mapIssueToFeature(issue, featureIndex, epicsMap);
+                    result.features.push(feature);
+                    featureIndex++;
+                    result.stats.featuresImported++;
+                }
+                catch (error) {
+                    result.errors.push({
+                        field: issue.key,
+                        message: error instanceof Error ? error.message : 'Failed to import issue',
+                        originalItem: issue,
+                    });
+                    result.stats.errors++;
+                }
+            }
+            if (!options.dryRun && result.features.length > 0) {
+                await this.writeFeatures(result.features, options.outputFile || 'features.csv', options.merge || false);
+            }
+            result.success = result.errors.length === 0;
+            return result;
+        }
+        catch (error) {
+            result.errors.push({ message: error instanceof Error ? error.message : 'Import failed' });
+            return result;
+        }
+    }
+    extractEpics(issues) {
+        const epics = new Map();
+        for (const issue of issues) {
+            if (issue.fields.issuetype.name.toLowerCase() === 'epic') {
+                epics.set(issue.key, {
+                    id: this.sanitizeId(issue.fields.summary),
+                    name: issue.fields.summary,
+                    description: issue.fields.description || '',
+                    originalId: issue.key,
+                    originalType: 'Epic',
+                });
+            }
+        }
+        for (const issue of issues) {
+            const epicKey = issue.fields.parent?.key || issue.fields.customfield_10014;
+            if (epicKey && !epics.has(epicKey)) {
+                const parentSummary = issue.fields.parent?.fields.summary || epicKey;
+                epics.set(epicKey, {
+                    id: this.sanitizeId(parentSummary),
+                    name: parentSummary,
+                    description: '',
+                    originalId: epicKey,
+                    originalType: 'Epic',
+                });
+            }
+        }
+        return epics;
+    }
+    mapIssueToFeature(issue, index, epicsMap) {
+        const epicKey = issue.fields.parent?.key || issue.fields.customfield_10014;
+        const epic = epicKey ? epicsMap.get(epicKey) : undefined;
+        return {
+            id: this.generateFeatureId('feat', index),
+            name: issue.fields.summary,
+            description: issue.fields.description || issue.fields.summary,
+            estimate: this.convertToHours(issue.fields.timeoriginalestimate),
+            assignee: issue.fields.assignee?.displayName || 'Unassigned',
+            priority: this.mapPriority(issue.fields.priority?.name || 'medium'),
+            status: this.mapStatus(issue.fields.status.name),
+            category: epic?.name || 'Uncategorized',
+            tags: [issue.fields.issuetype.name, ...issue.fields.labels, `jira:${issue.key}`],
+            createdDate: this.formatDate(issue.fields.created),
+            dueDate: this.formatDate(issue.fields.duedate),
+        };
+    }
+}
+// ============================================================================
+// Linear Importer
+// ============================================================================
+export class LinearImporter extends BaseImporter {
+    name = 'Linear Importer';
+    source = 'linear';
+    description = 'Import issues from Linear JSON export file';
+    async validate(content) {
+        const errors = [];
+        try {
+            const data = this.parseJSON(content);
+            const result = LinearExportSchema.safeParse(data);
+            if (!result.success) {
+                errors.push('Invalid Linear export format');
+                result.error.issues.forEach(err => errors.push(`${err.path.join('.')}: ${err.message}`));
+                return { valid: false, errors };
+            }
+            if (result.data.issues.length === 0) {
+                errors.push('No issues found in export');
+                return { valid: false, errors };
+            }
+            return { valid: true, errors: [] };
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : 'Unknown validation error');
+            return { valid: false, errors };
+        }
+    }
+    async import(options) {
+        const result = this.createEmptyResult();
+        try {
+            const content = await this.getContent(options);
+            const parseResult = LinearExportSchema.safeParse(this.parseJSON(content));
+            if (!parseResult.success) {
+                result.errors.push({ message: 'Invalid Linear export format' });
+                return result;
+            }
+            const linearData = parseResult.data;
+            result.stats.totalItems = linearData.issues.length;
+            const projectsMap = this.extractProjects(linearData);
+            result.epics = Array.from(projectsMap.values());
+            result.stats.epicsImported = result.epics.length;
+            let featureIndex = 1;
+            for (const issue of linearData.issues) {
+                try {
+                    const feature = this.mapIssueToFeature(issue, featureIndex, projectsMap);
+                    result.features.push(feature);
+                    featureIndex++;
+                    result.stats.featuresImported++;
+                }
+                catch (error) {
+                    result.errors.push({
+                        field: issue.identifier,
+                        message: error instanceof Error ? error.message : 'Failed to import issue',
+                        originalItem: issue,
+                    });
+                    result.stats.errors++;
+                }
+            }
+            if (!options.dryRun && result.features.length > 0) {
+                await this.writeFeatures(result.features, options.outputFile || 'features.csv', options.merge || false);
+            }
+            result.success = result.errors.length === 0;
+            return result;
+        }
+        catch (error) {
+            result.errors.push({ message: error instanceof Error ? error.message : 'Import failed' });
+            return result;
+        }
+    }
+    extractProjects(data) {
+        const projects = new Map();
+        if (data.projects) {
+            for (const project of data.projects) {
+                projects.set(project.id, {
+                    id: this.sanitizeId(project.name),
+                    name: project.name,
+                    description: project.description || '',
+                    originalId: project.id,
+                    originalType: 'Project',
+                });
+            }
+        }
+        for (const issue of data.issues) {
+            if (issue.project && !projects.has(issue.project.id)) {
+                projects.set(issue.project.id, {
+                    id: this.sanitizeId(issue.project.name),
+                    name: issue.project.name,
+                    description: issue.project.description || '',
+                    originalId: issue.project.id,
+                    originalType: 'Project',
+                });
+            }
+        }
+        return projects;
+    }
+    mapLinearPriority(priority) {
+        switch (priority) {
+            case 1: return 'critical';
+            case 2: return 'high';
+            case 3: return 'medium';
+            case 4: return 'low';
+            default: return 'medium';
+        }
+    }
+    mapLinearState(state) {
+        const type = state.type.toLowerCase();
+        switch (type) {
+            case 'completed':
+            case 'done': return 'done';
+            case 'started':
+            case 'inprogress': return 'in-progress';
+            case 'backlog':
+            case 'unstarted':
+            case 'triage': return 'todo';
+            case 'canceled':
+            case 'cancelled': return 'blocked';
+            default: return this.mapStatus(state.name);
+        }
+    }
+    mapIssueToFeature(issue, index, projectsMap) {
+        const project = issue.project ? projectsMap.get(issue.project.id) : undefined;
+        const labels = issue.labels?.nodes?.map(l => l.name) || [];
+        return {
+            id: this.generateFeatureId('feat', index),
+            name: issue.title,
+            description: issue.description || issue.title,
+            estimate: issue.estimate ? issue.estimate * 4 : 8,
+            assignee: issue.assignee?.name || 'Unassigned',
+            priority: this.mapLinearPriority(issue.priority),
+            status: this.mapLinearState(issue.state),
+            category: project?.name || 'Uncategorized',
+            tags: [...labels, `linear:${issue.identifier}`],
+            createdDate: this.formatDate(issue.createdAt),
+            dueDate: this.formatDate(issue.dueDate),
+        };
+    }
+}
+// ============================================================================
+// GitHub Importer
+// ============================================================================
+const SKILL_LABEL_PREFIXES = ['skill:', 'tech:', 'language:', 'framework:'];
+export class GitHubImporter extends BaseImporter {
+    name = 'GitHub Issues Importer';
+    source = 'github';
+    description = 'Import issues from GitHub API export or JSON file';
+    async validate(content) {
+        const errors = [];
+        try {
+            const data = this.parseJSON(content);
+            const normalized = Array.isArray(data) ? { issues: data } : data;
+            const result = GitHubExportSchema.safeParse(normalized);
+            if (!result.success) {
+                errors.push('Invalid GitHub export format');
+                result.error.issues.forEach(err => errors.push(`${err.path.join('.')}: ${err.message}`));
+                return { valid: false, errors };
+            }
+            if (result.data.issues.length === 0) {
+                errors.push('No issues found in export');
+                return { valid: false, errors };
+            }
+            return { valid: true, errors: [] };
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : 'Unknown validation error');
+            return { valid: false, errors };
+        }
+    }
+    async import(options) {
+        const result = this.createEmptyResult();
+        try {
+            const content = await this.getContent(options);
+            const rawData = this.parseJSON(content);
+            const normalized = Array.isArray(rawData) ? { issues: rawData } : rawData;
+            const parseResult = GitHubExportSchema.safeParse(normalized);
+            if (!parseResult.success) {
+                result.errors.push({ message: 'Invalid GitHub export format' });
+                return result;
+            }
+            const githubData = parseResult.data;
+            result.stats.totalItems = githubData.issues.length;
+            const milestonesMap = this.extractMilestones(githubData);
+            result.milestones = Array.from(milestonesMap.values());
+            result.stats.milestonesImported = result.milestones.length;
+            const epicsMap = this.extractEpicsFromLabels(githubData.issues);
+            result.epics = Array.from(epicsMap.values());
+            result.stats.epicsImported = result.epics.length;
+            let featureIndex = 1;
+            for (const issue of githubData.issues) {
+                try {
+                    const feature = this.mapIssueToFeature(issue, featureIndex, milestonesMap, epicsMap);
+                    result.features.push(feature);
+                    featureIndex++;
+                    result.stats.featuresImported++;
+                }
+                catch (error) {
+                    result.errors.push({
+                        field: `#${issue.number}`,
+                        message: error instanceof Error ? error.message : 'Failed to import issue',
+                        originalItem: issue,
+                    });
+                    result.stats.errors++;
+                }
+            }
+            if (!options.dryRun && result.features.length > 0) {
+                await this.writeFeatures(result.features, options.outputFile || 'features.csv', options.merge || false);
+            }
+            result.success = result.errors.length === 0;
+            return result;
+        }
+        catch (error) {
+            result.errors.push({ message: error instanceof Error ? error.message : 'Import failed' });
+            return result;
+        }
+    }
+    extractMilestones(data) {
+        const milestones = new Map();
+        if (data.milestones) {
+            for (const milestone of data.milestones) {
+                milestones.set(milestone.number, {
+                    id: this.sanitizeId(milestone.title),
+                    name: milestone.title,
+                    description: milestone.description || '',
+                    dueDate: this.formatDate(milestone.due_on),
+                    originalId: String(milestone.number),
+                });
+            }
+        }
+        for (const issue of data.issues) {
+            if (issue.milestone && !milestones.has(issue.milestone.number)) {
+                milestones.set(issue.milestone.number, {
+                    id: this.sanitizeId(issue.milestone.title),
+                    name: issue.milestone.title,
+                    description: issue.milestone.description || '',
+                    dueDate: this.formatDate(issue.milestone.due_on),
+                    originalId: String(issue.milestone.number),
+                });
+            }
+        }
+        return milestones;
+    }
+    extractEpicsFromLabels(issues) {
+        const epics = new Map();
+        const epicPrefixes = ['epic:', 'category:', 'area:'];
+        for (const issue of issues) {
+            for (const label of issue.labels) {
+                const lowerName = label.name.toLowerCase();
+                for (const prefix of epicPrefixes) {
+                    if (lowerName.startsWith(prefix)) {
+                        const epicName = label.name.substring(prefix.length).trim();
+                        if (!epics.has(epicName)) {
+                            epics.set(epicName, {
+                                id: this.sanitizeId(epicName),
+                                name: epicName,
+                                description: `Imported from GitHub label: ${label.name}`,
+                                originalId: label.name,
+                                originalType: 'Label',
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        return epics;
+    }
+    extractSkillsFromLabels(labels) {
+        const skills = [];
+        for (const label of labels) {
+            const lowerName = label.name.toLowerCase();
+            for (const prefix of SKILL_LABEL_PREFIXES) {
+                if (lowerName.startsWith(prefix)) {
+                    skills.push(label.name.substring(prefix.length).trim());
+                    break;
+                }
+            }
+        }
+        return skills;
+    }
+    extractCategoryFromLabels(labels, epicsMap) {
+        const epicPrefixes = ['epic:', 'category:', 'area:'];
+        for (const label of labels) {
+            const lowerName = label.name.toLowerCase();
+            for (const prefix of epicPrefixes) {
+                if (lowerName.startsWith(prefix)) {
+                    const epicName = label.name.substring(prefix.length).trim();
+                    if (epicsMap.has(epicName))
+                        return epicName;
+                }
+            }
+        }
+        return 'Uncategorized';
+    }
+    extractPriorityFromLabels(labels) {
+        const priorityPrefixes = ['priority:', 'p:'];
+        for (const label of labels) {
+            const lowerName = label.name.toLowerCase();
+            for (const prefix of priorityPrefixes) {
+                if (lowerName.startsWith(prefix)) {
+                    return this.mapPriority(lowerName.substring(prefix.length).trim());
+                }
+            }
+            if (['critical', 'blocker', 'urgent'].includes(lowerName))
+                return 'critical';
+            if (['high', 'important'].includes(lowerName))
+                return 'high';
+            if (['low', 'minor', 'trivial'].includes(lowerName))
+                return 'low';
+        }
+        return 'medium';
+    }
+    extractEstimateFromLabels(labels) {
+        const estimatePrefixes = ['estimate:', 'size:', 'points:'];
+        for (const label of labels) {
+            const lowerName = label.name.toLowerCase();
+            for (const prefix of estimatePrefixes) {
+                if (lowerName.startsWith(prefix)) {
+                    const value = lowerName.substring(prefix.length).trim();
+                    const parsed = parseInt(value, 10);
+                    if (!isNaN(parsed))
+                        return parsed * 4;
+                }
+            }
+            if (['xs', 'extra-small'].includes(lowerName))
+                return 2;
+            if (['s', 'small'].includes(lowerName))
+                return 4;
+            if (['m', 'medium'].includes(lowerName))
+                return 8;
+            if (['l', 'large'].includes(lowerName))
+                return 16;
+            if (['xl', 'extra-large'].includes(lowerName))
+                return 32;
+        }
+        return 8;
+    }
+    mapIssueToFeature(issue, index, milestonesMap, epicsMap) {
+        const category = this.extractCategoryFromLabels(issue.labels, epicsMap);
+        const priority = this.extractPriorityFromLabels(issue.labels);
+        const status = issue.state === 'closed' ? 'done' : 'todo';
+        const estimate = this.extractEstimateFromLabels(issue.labels);
+        const assignee = issue.assignee?.login ||
+            (issue.assignees && issue.assignees.length > 0 ? issue.assignees[0].login : 'Unassigned');
+        const skills = this.extractSkillsFromLabels(issue.labels);
+        const otherLabels = issue.labels.map(l => l.name).filter(name => {
+            const lower = name.toLowerCase();
+            const excludePrefixes = [...SKILL_LABEL_PREFIXES, 'epic:', 'category:', 'area:', 'priority:', 'p:', 'estimate:', 'size:', 'points:'];
+            return !excludePrefixes.some(p => lower.startsWith(p)) &&
+                !['critical', 'blocker', 'urgent', 'high', 'important', 'low', 'minor', 'trivial',
+                    'xs', 'extra-small', 's', 'small', 'm', 'medium', 'l', 'large', 'xl', 'extra-large'].includes(lower);
+        });
+        const tags = [...skills, ...otherLabels, `github:#${issue.number}`];
+        if (issue.milestone)
+            tags.push(`milestone:${issue.milestone.title}`);
+        return {
+            id: this.generateFeatureId('feat', index),
+            name: issue.title,
+            description: issue.body || issue.title,
+            estimate,
+            assignee,
+            priority,
+            status,
+            category,
+            tags,
+            createdDate: this.formatDate(issue.created_at),
+            dueDate: issue.milestone?.due_on ? this.formatDate(issue.milestone.due_on) : undefined,
+        };
+    }
+}
+// ============================================================================
+// Importer Registry
+// ============================================================================
+export const jiraImporter = new JiraImporter();
+export const linearImporter = new LinearImporter();
+export const githubImporter = new GitHubImporter();
+const importerRegistry = {
+    jira: jiraImporter,
+    linear: linearImporter,
+    github: githubImporter,
+};
+export function getImporter(source) {
+    const importer = importerRegistry[source];
+    if (!importer)
+        throw new Error(`Unknown import source: ${source}`);
+    return importer;
+}
+export function getAllImporters() {
+    return Object.values(importerRegistry);
+}
+export function isValidSource(source) {
+    return source in importerRegistry;
+}
+//# sourceMappingURL=importers.js.map