gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/dist/resources/extensions/gsd/paths.js

@@ -0,0 +1,414 @@
+/**
+ * GSD Paths — ID-based path resolution
+ *
+ * Directories use bare IDs: M001/, S01/, etc.
+ * Files use ID-SUFFIX: M001-ROADMAP.md, S01-PLAN.md, T01-PLAN.md
+ *
+ * Resolvers still handle legacy descriptor-suffixed names
+ * (e.g. M001-FLIGHT-SIMULATOR/, T03-INSTALL-PACKAGES-PLAN.md)
+ * via prefix matching, so existing projects work without migration.
+ */
+import { readdirSync, existsSync, realpathSync, Dirent } from "node:fs";
+import { join } from "node:path";
+import { nativeScanGsdTree } from "./native-parser-bridge.js";
+import { DIR_CACHE_MAX } from "./constants.js";
+// ─── Directory Listing Cache ──────────────────────────────────────────────────
+const dirEntryCache = new Map();
+const dirListCache = new Map();
+// ─── Native Tree Cache ────────────────────────────────────────────────────────
+// When the native module is available, scan the entire .gsd/ tree in one call
+// and serve directory listings from memory instead of individual readdirSync calls.
+let nativeTreeCache = null;
+let nativeTreeBase = null;
+function getNativeTree(gsdDir) {
+    if (nativeTreeCache && nativeTreeBase === gsdDir)
+        return nativeTreeCache;
+    const entries = nativeScanGsdTree(gsdDir);
+    if (!entries)
+        return null;
+    // Build a map of parent directory -> entries
+    const tree = new Map();
+    for (const entry of entries) {
+        const parts = entry.path.split('/');
+        const parentPath = parts.slice(0, -1).join('/');
+        const parentKey = parentPath || '.';
+        if (!tree.has(parentKey))
+            tree.set(parentKey, []);
+        tree.get(parentKey).push(entry);
+    }
+    nativeTreeCache = tree;
+    nativeTreeBase = gsdDir;
+    return tree;
+}
+/**
+ * Convert a native tree lookup into a relative key for the tree map.
+ * Returns the relative path from the gsdDir, or null if the path isn't under gsdDir.
+ */
+function nativeTreeKey(dirPath, gsdDir) {
+    if (!dirPath.startsWith(gsdDir))
+        return null;
+    const rel = dirPath.slice(gsdDir.length).replace(/^\//, '');
+    return rel || '.';
+}
+function cachedReaddirWithTypes(dirPath) {
+    const cached = dirEntryCache.get(dirPath);
+    if (cached)
+        return cached;
+    // Try native tree cache for paths under .gsd/
+    if (nativeTreeBase) {
+        const key = nativeTreeKey(dirPath, nativeTreeBase);
+        if (key && nativeTreeCache) {
+            const treeEntries = nativeTreeCache.get(key);
+            if (treeEntries) {
+                // Synthesize Dirent-like objects from native tree entries
+                const dirents = treeEntries.map(e => {
+                    const d = Object.create(Dirent.prototype);
+                    Object.assign(d, {
+                        name: e.name,
+                        parentPath: dirPath,
+                        path: dirPath,
+                    });
+                    // Override the type check methods
+                    const isDir = e.isDir;
+                    d.isDirectory = () => isDir;
+                    d.isFile = () => !isDir;
+                    d.isSymbolicLink = () => false;
+                    d.isBlockDevice = () => false;
+                    d.isCharacterDevice = () => false;
+                    d.isFIFO = () => false;
+                    d.isSocket = () => false;
+                    return d;
+                });
+                if (dirEntryCache.size >= DIR_CACHE_MAX)
+                    dirEntryCache.clear();
+                dirEntryCache.set(dirPath, dirents);
+                return dirents;
+            }
+        }
+    }
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    if (dirEntryCache.size >= DIR_CACHE_MAX)
+        dirEntryCache.clear();
+    dirEntryCache.set(dirPath, entries);
+    return entries;
+}
+function cachedReaddir(dirPath) {
+    const cached = dirListCache.get(dirPath);
+    if (cached)
+        return cached;
+    // Try native tree cache for paths under .gsd/
+    if (nativeTreeBase) {
+        const key = nativeTreeKey(dirPath, nativeTreeBase);
+        if (key && nativeTreeCache) {
+            const treeEntries = nativeTreeCache.get(key);
+            if (treeEntries) {
+                const names = treeEntries.map(e => e.name);
+                if (dirListCache.size >= DIR_CACHE_MAX)
+                    dirListCache.clear();
+                dirListCache.set(dirPath, names);
+                return names;
+            }
+        }
+    }
+    const entries = readdirSync(dirPath);
+    if (dirListCache.size >= DIR_CACHE_MAX)
+        dirListCache.clear();
+    dirListCache.set(dirPath, entries);
+    return entries;
+}
+/**
+ * Clear the directory listing cache.
+ * Call after milestone transitions, file creation in planning directories,
+ * or at the start/end of a dispatch cycle.
+ */
+export function clearPathCache() {
+    dirEntryCache.clear();
+    dirListCache.clear();
+    nativeTreeCache = null;
+    nativeTreeBase = null;
+}
+// ─── Name Builders ─────────────────────────────────────────────────────────
+/**
+ * Build a milestone-level file name.
+ * ("M001", "CONTEXT") → "M001-CONTEXT.md"
+ */
+export function buildMilestoneFileName(milestoneId, suffix) {
+    return `${milestoneId}-${suffix}.md`;
+}
+/**
+ * Build a slice-level file name.
+ * ("S01", "PLAN") → "S01-PLAN.md"
+ */
+export function buildSliceFileName(sliceId, suffix) {
+    return `${sliceId}-${suffix}.md`;
+}
+/**
+ * Build a task file name.
+ * ("T03", "PLAN") → "T03-PLAN.md"
+ * ("T03", "SUMMARY") → "T03-SUMMARY.md"
+ */
+export function buildTaskFileName(taskId, suffix) {
+    return `${taskId}-${suffix}.md`;
+}
+// ─── Resolvers ─────────────────────────────────────────────────────────────
+/**
+ * Find a directory entry by ID prefix within a parent directory.
+ * Exact match first (M001), then prefix match (M001-SOMETHING) for
+ * backward compatibility with legacy descriptor directories.
+ * Returns the full directory name or null.
+ */
+export function resolveDir(parentDir, idPrefix) {
+    if (!existsSync(parentDir))
+        return null;
+    try {
+        const entries = cachedReaddirWithTypes(parentDir);
+        // Exact match first (current convention: bare ID)
+        const exact = entries.find(e => e.isDirectory() && e.name === idPrefix);
+        if (exact)
+            return exact.name;
+        // Prefix match for legacy descriptor dirs: M001-SOMETHING
+        const prefixed = entries.find(e => e.isDirectory() && e.name.startsWith(idPrefix + "-"));
+        return prefixed ? prefixed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find a file by ID prefix and suffix within a directory.
+ * Checks in order:
+ *   1. Direct: ID-SUFFIX.md (e.g. M001-ROADMAP.md, T03-PLAN.md)
+ *   2. Legacy descriptor: ID-DESCRIPTOR-SUFFIX.md (e.g. T03-INSTALL-PACKAGES-PLAN.md)
+ *   3. Legacy bare: suffix.md (e.g. roadmap.md)
+ */
+export function resolveFile(dir, idPrefix, suffix) {
+    if (!existsSync(dir))
+        return null;
+    const target = `${idPrefix}-${suffix}.md`.toUpperCase();
+    try {
+        const entries = cachedReaddir(dir);
+        // Direct match: ID-SUFFIX.md
+        const direct = entries.find(e => e.toUpperCase() === target);
+        if (direct)
+            return direct;
+        // Legacy pattern match: ID-DESCRIPTOR-SUFFIX.md
+        const pattern = new RegExp(`^${idPrefix}-.*-${suffix}\\.md$`, "i");
+        const match = entries.find(e => pattern.test(e));
+        if (match)
+            return match;
+        // Legacy fallback: suffix.md
+        const legacy = entries.find(e => e.toLowerCase() === `${suffix.toLowerCase()}.md`);
+        if (legacy)
+            return legacy;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find all task files matching a pattern in a tasks directory.
+ * Returns sorted file names matching T##-SUFFIX.md or legacy T##-*-SUFFIX.md
+ */
+export function resolveTaskFiles(tasksDir, suffix) {
+    if (!existsSync(tasksDir))
+        return [];
+    try {
+        // Current convention: T01-PLAN.md
+        const currentPattern = new RegExp(`^T\\d+-${suffix}\\.md$`, "i");
+        // Legacy convention: T01-INSTALL-PACKAGES-PLAN.md
+        const legacyPattern = new RegExp(`^T\\d+-.*-${suffix}\\.md$`, "i");
+        return cachedReaddir(tasksDir)
+            .filter(f => currentPattern.test(f) || legacyPattern.test(f))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find all task JSON files matching a pattern in a tasks directory.
+ * Returns sorted file names matching T##-SUFFIX.json or legacy T##-*-SUFFIX.json
+ */
+export function resolveTaskJsonFiles(tasksDir, suffix) {
+    if (!existsSync(tasksDir))
+        return [];
+    try {
+        const currentPattern = new RegExp(`^T\\d+-${suffix}\\.json$`, "i");
+        const legacyPattern = new RegExp(`^T\\d+-.*-${suffix}\\.json$`, "i");
+        return cachedReaddir(tasksDir)
+            .filter(f => currentPattern.test(f) || legacyPattern.test(f))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Full Path Builders ────────────────────────────────────────────────────
+export const GSD_ROOT_FILES = {
+    PROJECT: "PROJECT.md",
+    DECISIONS: "DECISIONS.md",
+    QUEUE: "QUEUE.md",
+    STATE: "STATE.md",
+    REQUIREMENTS: "REQUIREMENTS.md",
+    OVERRIDES: "OVERRIDES.md",
+    KNOWLEDGE: "KNOWLEDGE.md",
+};
+const LEGACY_GSD_ROOT_FILES = {
+    PROJECT: "project.md",
+    DECISIONS: "decisions.md",
+    QUEUE: "queue.md",
+    STATE: "state.md",
+    REQUIREMENTS: "requirements.md",
+    OVERRIDES: "overrides.md",
+    KNOWLEDGE: "knowledge.md",
+};
+export function gsdRoot(basePath) {
+    const local = join(basePath, ".gsd");
+    try {
+        const resolved = realpathSync(local);
+        if (resolved !== local)
+            return resolved; // symlink resolved
+    }
+    catch { /* doesn't exist yet — fall through */ }
+    return local; // backwards compat: unmigrated projects
+}
+export function milestonesDir(basePath) {
+    return join(gsdRoot(basePath), "milestones");
+}
+export function resolveGsdRootFile(basePath, key) {
+    const root = gsdRoot(basePath);
+    const canonical = join(root, GSD_ROOT_FILES[key]);
+    if (existsSync(canonical))
+        return canonical;
+    const legacy = join(root, LEGACY_GSD_ROOT_FILES[key]);
+    if (existsSync(legacy))
+        return legacy;
+    return canonical;
+}
+export function relGsdRootFile(key) {
+    return `.gsd/${GSD_ROOT_FILES[key]}`;
+}
+/**
+ * Resolve the full path to a milestone directory.
+ * Returns null if the milestone doesn't exist.
+ */
+export function resolveMilestonePath(basePath, milestoneId) {
+    const dir = resolveDir(milestonesDir(basePath), milestoneId);
+    return dir ? join(milestonesDir(basePath), dir) : null;
+}
+/**
+ * Resolve the full path to a milestone file (e.g. ROADMAP, CONTEXT, RESEARCH).
+ */
+export function resolveMilestoneFile(basePath, milestoneId, suffix) {
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (!mDir)
+        return null;
+    const file = resolveFile(mDir, milestoneId, suffix);
+    return file ? join(mDir, file) : null;
+}
+/**
+ * Resolve the full path to a slice directory within a milestone.
+ */
+export function resolveSlicePath(basePath, milestoneId, sliceId) {
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (!mDir)
+        return null;
+    const slicesDir = join(mDir, "slices");
+    const dir = resolveDir(slicesDir, sliceId);
+    return dir ? join(slicesDir, dir) : null;
+}
+/**
+ * Resolve the full path to a slice file (e.g. PLAN, RESEARCH, CONTEXT, SUMMARY).
+ */
+export function resolveSliceFile(basePath, milestoneId, sliceId, suffix) {
+    const sDir = resolveSlicePath(basePath, milestoneId, sliceId);
+    if (!sDir)
+        return null;
+    const file = resolveFile(sDir, sliceId, suffix);
+    return file ? join(sDir, file) : null;
+}
+/**
+ * Resolve the tasks directory within a slice.
+ */
+export function resolveTasksDir(basePath, milestoneId, sliceId) {
+    const sDir = resolveSlicePath(basePath, milestoneId, sliceId);
+    if (!sDir)
+        return null;
+    const tDir = join(sDir, "tasks");
+    return existsSync(tDir) ? tDir : null;
+}
+/**
+ * Resolve a specific task file.
+ */
+export function resolveTaskFile(basePath, milestoneId, sliceId, taskId, suffix) {
+    const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (!tDir)
+        return null;
+    const file = resolveFile(tDir, taskId, suffix);
+    return file ? join(tDir, file) : null;
+}
+// ─── Relative Path Builders (for prompts — .gsd/milestones/...) ────────────
+/**
+ * Build relative .gsd/ path to a milestone directory.
+ * Uses the actual directory name on disk if it exists, otherwise bare ID.
+ */
+export function relMilestonePath(basePath, milestoneId) {
+    const dir = resolveDir(milestonesDir(basePath), milestoneId);
+    if (dir)
+        return `.gsd/milestones/${dir}`;
+    return `.gsd/milestones/${milestoneId}`;
+}
+/**
+ * Build relative .gsd/ path to a milestone file.
+ */
+export function relMilestoneFile(basePath, milestoneId, suffix) {
+    const mRel = relMilestonePath(basePath, milestoneId);
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (mDir) {
+        const file = resolveFile(mDir, milestoneId, suffix);
+        if (file)
+            return `${mRel}/${file}`;
+    }
+    return `${mRel}/${buildMilestoneFileName(milestoneId, suffix)}`;
+}
+/**
+ * Build relative .gsd/ path to a slice directory.
+ */
+export function relSlicePath(basePath, milestoneId, sliceId) {
+    const mRel = relMilestonePath(basePath, milestoneId);
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    if (mDir) {
+        const slicesDir = join(mDir, "slices");
+        const dir = resolveDir(slicesDir, sliceId);
+        if (dir)
+            return `${mRel}/slices/${dir}`;
+    }
+    return `${mRel}/slices/${sliceId}`;
+}
+/**
+ * Build relative .gsd/ path to a slice file.
+ */
+export function relSliceFile(basePath, milestoneId, sliceId, suffix) {
+    const sRel = relSlicePath(basePath, milestoneId, sliceId);
+    const sDir = resolveSlicePath(basePath, milestoneId, sliceId);
+    if (sDir) {
+        const file = resolveFile(sDir, sliceId, suffix);
+        if (file)
+            return `${sRel}/${file}`;
+    }
+    return `${sRel}/${buildSliceFileName(sliceId, suffix)}`;
+}
+/**
+ * Build relative .gsd/ path to a task file.
+ */
+export function relTaskFile(basePath, milestoneId, sliceId, taskId, suffix) {
+    const sRel = relSlicePath(basePath, milestoneId, sliceId);
+    const tDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (tDir) {
+        const file = resolveFile(tDir, taskId, suffix);
+        if (file)
+            return `${sRel}/tasks/${file}`;
+    }
+    return `${sRel}/tasks/${buildTaskFileName(taskId, suffix)}`;
+}

package/dist/resources/extensions/gsd/plugin-importer.js

@@ -0,0 +1,254 @@
+/**
+ * PluginImporter Service
+ *
+ * Composes S01-S04 modules into a staged discover → select → validate → commit pipeline.
+ * Each stage is independently testable. The service owns no UI — it produces data structures
+ * that the command layer (T02) consumes.
+ *
+ * Pipeline stages:
+ * 1. discover(marketplacePaths) - Read marketplace manifests, populate registry
+ * 2. selectComponents(filter) - Filter to user-chosen components
+ * 3. validateImport(selected) - Check for collisions, return diagnostics
+ * 4. getImportManifest(selected) - Produce serializable config structure
+ *
+ * This service implements R012 (discover/select/import flow) and R013 (canonical name preservation).
+ */
+import { discoverMarketplace, } from './marketplace-discovery.js';
+import { GSDError, GSD_STALE_STATE } from './errors.js';
+import { NamespacedRegistry, componentsFromDiscovery, } from './namespaced-registry.js';
+import { NamespacedResolver } from './namespaced-resolver.js';
+import { analyzeCollisions, } from './collision-diagnostics.js';
+// ============================================================================
+// PluginImporter Class
+// ============================================================================
+/**
+ * Service for discovering, selecting, validating, and importing plugin components.
+ *
+ * Usage:
+ * ```typescript
+ * const importer = new PluginImporter();
+ *
+ * // Stage 1: Discover
+ * const discovery = importer.discover(['../claude-plugins']);
+ *
+ * // Stage 2: Select
+ * const selected = importer.selectComponents(c => c.namespace === 'my-plugin');
+ *
+ * // Stage 3: Validate
+ * const validation = importer.validateImport(selected);
+ * if (!validation.canProceed) {
+ *   console.error('Cannot import:', validation.diagnostics);
+ *   return;
+ * }
+ *
+ * // Stage 4: Get manifest for persistence
+ * const manifest = importer.getImportManifest(selected);
+ * ```
+ */
+export class PluginImporter {
+    /** The internal registry populated during discovery */
+    registry = null;
+    /** All discovered plugins from the last discovery run */
+    discoveredPlugins = [];
+    /** Last discovery result for inspection */
+    lastDiscoveryResult = null;
+    /** Last validation result for inspection */
+    lastValidationResult = null;
+    /**
+     * Stage 1: Discover plugins from marketplace paths.
+     *
+     * Calls `discoverMarketplace()` for each path and populates a `NamespacedRegistry`
+     * via `componentsFromDiscovery()`.
+     *
+     * @param marketplacePaths - Array of paths to marketplace directories
+     * @returns Discovery result with registry and summary
+     */
+    discover(marketplacePaths) {
+        // Reset state for fresh discovery
+        this.registry = new NamespacedRegistry();
+        this.discoveredPlugins = [];
+        this.lastValidationResult = null;
+        const marketplaceResults = [];
+        let marketplacesWithErrors = 0;
+        let pluginsWithErrors = 0;
+        // Process each marketplace path
+        for (const marketplacePath of marketplacePaths) {
+            const result = discoverMarketplace(marketplacePath);
+            marketplaceResults.push(result);
+            if (result.status === 'error') {
+                marketplacesWithErrors++;
+            }
+            // Collect all plugins
+            for (const plugin of result.plugins) {
+                this.discoveredPlugins.push(plugin);
+                if (plugin.status === 'error') {
+                    pluginsWithErrors++;
+                }
+                // Convert plugin inventory to components and register
+                const components = componentsFromDiscovery(plugin);
+                for (const component of components) {
+                    this.registry.register(component);
+                }
+            }
+        }
+        // Build summary
+        const summary = {
+            marketplacesProcessed: marketplacePaths.length,
+            marketplacesWithErrors,
+            totalPlugins: this.discoveredPlugins.length,
+            pluginsWithErrors,
+            totalComponents: this.registry.size,
+        };
+        this.lastDiscoveryResult = {
+            marketplaceResults,
+            plugins: this.discoveredPlugins,
+            registry: this.registry,
+            summary,
+        };
+        return this.lastDiscoveryResult;
+    }
+    /**
+     * Stage 2: Select components by filter function.
+     *
+     * Returns a filtered subset of registered components.
+     * Must be called after discover().
+     *
+     * @param componentFilter - Filter function returning true for selected components
+     * @returns Array of selected components
+     */
+    selectComponents(componentFilter) {
+        if (!this.registry) {
+            throw new GSDError(GSD_STALE_STATE, 'Must call discover() before selectComponents()');
+        }
+        return this.registry.getAll().filter(componentFilter);
+    }
+    /**
+     * Stage 3: Validate selected components for import.
+     *
+     * Builds a `NamespacedResolver`, runs `analyzeCollisions()`, and returns
+     * `{ diagnostics, canProceed }` where `canProceed` is false if any
+     * error-severity diagnostics exist.
+     *
+     * @param selected - Array of components to validate
+     * @returns Validation result with diagnostics and proceed flag
+     */
+    validateImport(selected) {
+        if (!this.registry) {
+            throw new GSDError(GSD_STALE_STATE, 'Must call discover() before validateImport()');
+        }
+        // Create a temporary resolver for the selected components
+        const tempRegistry = new NamespacedRegistry();
+        // Register only selected components into temp registry
+        for (const component of selected) {
+            tempRegistry.register({
+                name: component.name,
+                namespace: component.namespace,
+                type: component.type,
+                filePath: component.filePath,
+                source: component.source,
+                description: component.description,
+                metadata: component.metadata,
+            });
+        }
+        // Create resolver and analyze collisions
+        const resolver = new NamespacedResolver(tempRegistry);
+        const diagnostics = analyzeCollisions(tempRegistry, resolver);
+        // Count by severity
+        const errors = diagnostics.filter((d) => d.severity === 'error').length;
+        const warnings = diagnostics.filter((d) => d.severity === 'warning').length;
+        const summary = {
+            total: diagnostics.length,
+            errors,
+            warnings,
+        };
+        // canProceed is false if any error-severity diagnostics exist
+        const canProceed = errors === 0;
+        this.lastValidationResult = {
+            diagnostics,
+            canProceed,
+            summary,
+        };
+        return this.lastValidationResult;
+    }
+    /**
+     * Stage 4: Generate import manifest for selected components.
+     *
+     * Produces a serializable config structure with canonical names preserved.
+     * The manifest can be persisted to config files.
+     *
+     * @param selected - Array of components to include in manifest
+     * @returns Import manifest with all entries and metadata
+     */
+    getImportManifest(selected) {
+        const entries = selected.map((component) => ({
+            canonicalName: component.canonicalName,
+            type: component.type,
+            name: component.name,
+            namespace: component.namespace,
+            filePath: component.filePath,
+            source: component.source,
+            description: component.description,
+            metadata: {
+                pluginVersion: component.metadata.pluginVersion,
+                pluginAuthor: component.metadata.pluginAuthor,
+                pluginHomepage: component.metadata.pluginHomepage,
+                pluginCategory: component.metadata.pluginCategory,
+            },
+        }));
+        // Count by type
+        const skills = entries.filter((e) => e.type === 'skill').length;
+        const agents = entries.filter((e) => e.type === 'agent').length;
+        // Collect unique namespaces
+        const namespaces = Array.from(new Set(entries.map((e) => e.namespace).filter((n) => n !== undefined))).sort();
+        return {
+            schemaVersion: '1.0',
+            generatedAt: new Date().toISOString(),
+            entries,
+            summary: {
+                total: entries.length,
+                skills,
+                agents,
+                namespaces,
+            },
+        };
+    }
+    /**
+     * Get the internal registry for inspection.
+     * Useful for debugging or advanced filtering.
+     *
+     * @returns The registry or null if discover() hasn't been called
+     */
+    getRegistry() {
+        return this.registry;
+    }
+    /**
+     * Get all discovered plugins.
+     *
+     * @returns Array of discovered plugins
+     */
+    getDiscoveredPlugins() {
+        return this.discoveredPlugins;
+    }
+    /**
+     * Get the last validation result.
+     * Useful for re-inspecting validation without re-running.
+     *
+     * @returns Last validation result or null
+     */
+    getLastValidation() {
+        return this.lastValidationResult;
+    }
+    /**
+     * Get the last discovery result.
+     * Useful for re-inspecting discovery without re-running.
+     *
+     * @returns Last discovery result or null
+     */
+    getLastDiscovery() {
+        return this.lastDiscoveryResult;
+    }
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export default PluginImporter;