skrypt-ai 0.4.2 → 0.5.0

package/dist/importers/docusaurus.js

@@ -0,0 +1,279 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, relative, basename, extname } from 'path';
+import { findMdxFiles } from '../utils/files.js';
+import { transformDocusaurusAdmonitions, transformDocusaurusTabs, stripDocusaurusImports, normalizeFrontmatter, getSortWeight, rewriteImagePaths, } from './transform.js';
+/**
+ * Import Docusaurus documentation.
+ */
+export function importDocusaurus(dir, name) {
+    const result = createEmptyResult(name);
+    const stats = { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 };
+    // Extract project info from docusaurus.config.js
+    const configPath = existsSync(join(dir, 'docusaurus.config.ts'))
+        ? join(dir, 'docusaurus.config.ts')
+        : join(dir, 'docusaurus.config.js');
+    if (existsSync(configPath)) {
+        const configContent = readFileSync(configPath, 'utf-8');
+        const titleMatch = configContent.match(/title:\s*['"]([^'"]+)['"]/);
+        const taglineMatch = configContent.match(/tagline:\s*['"]([^'"]+)['"]/);
+        if (titleMatch)
+            result.name = titleMatch[1];
+        if (taglineMatch)
+            result.description = taglineMatch[1];
+    }
+    if (name)
+        result.name = name;
+    // Find docs directory
+    const docsDir = existsSync(join(dir, 'docs')) ? join(dir, 'docs') : dir;
+    // Try to parse sidebars.js for navigation
+    const sidebarNav = parseSidebars(dir, docsDir);
+    if (sidebarNav && sidebarNav.length > 0) {
+        for (const group of sidebarNav) {
+            const pages = [];
+            for (const pageId of group.pageIds) {
+                const page = processDocusaurusPage(docsDir, pageId, stats, result);
+                if (page)
+                    pages.push(page);
+            }
+            if (pages.length > 0) {
+                result.navigation.push({ group: group.label, pages });
+            }
+        }
+    }
+    else {
+        // Fallback: walk docs/ with _category_.json
+        const groups = walkDocsDirectory(docsDir);
+        for (const group of groups) {
+            const pages = [];
+            for (const file of group.files) {
+                const pageId = relative(docsDir, file).replace(/\.(md|mdx)$/, '').replace(/\\/g, '/');
+                const page = processDocusaurusPage(docsDir, pageId, stats, result);
+                if (page)
+                    pages.push(page);
+            }
+            if (pages.length > 0) {
+                result.navigation.push({ group: group.label, pages });
+            }
+        }
+    }
+    // Copy static assets
+    const staticDir = join(dir, 'static');
+    if (existsSync(staticDir)) {
+        collectStaticAssets(staticDir, result, stats);
+    }
+    result.stats = {
+        pages: result.files.size,
+        groups: result.navigation.length,
+        transforms: stats,
+    };
+    return result;
+}
+function processDocusaurusPage(docsDir, pageId, stats, result) {
+    let filePath = join(docsDir, `${pageId}.mdx`);
+    if (!existsSync(filePath))
+        filePath = join(docsDir, `${pageId}.md`);
+    if (!existsSync(filePath))
+        filePath = join(docsDir, pageId, 'index.mdx');
+    if (!existsSync(filePath))
+        filePath = join(docsDir, pageId, 'index.md');
+    if (!existsSync(filePath)) {
+        result.warnings.push(`Page not found: ${pageId}`);
+        return null;
+    }
+    let content = readFileSync(filePath, 'utf-8');
+    const originalContent = content;
+    // Apply transforms
+    content = stripDocusaurusImports(content);
+    content = transformDocusaurusAdmonitions(content);
+    content = transformDocusaurusTabs(content);
+    content = normalizeFrontmatter(content);
+    // Strip Docusaurus-specific code fence metadata ({1,3-5} line highlighting)
+    content = content.replace(/^(```\w+)(?:\s+\{[\d,-]+\})/gm, '$1');
+    // Count transforms
+    stats.callouts += countNewOccurrences(originalContent, content, '<Callout');
+    stats.tabs += countNewOccurrences(originalContent, content, '<TabPanel');
+    const title = extractTitle(content, filePath);
+    const slug = pageId.replace(/\\/g, '/');
+    const outputPath = `content/docs/${slug}.mdx`;
+    result.files.set(outputPath, content);
+    return { title, slug, sourcePath: relative(docsDir, filePath), content };
+}
+function parseSidebars(rootDir, docsDir) {
+    const sidebarPath = join(rootDir, 'sidebars.js');
+    if (!existsSync(sidebarPath))
+        return null;
+    try {
+        const content = readFileSync(sidebarPath, 'utf-8');
+        const groups = [];
+        // Match category objects: { type: 'category', label: 'X', items: [...] }
+        const categoryRegex = /\{\s*type:\s*['"]category['"],\s*label:\s*['"]([^'"]+)['"]\s*,\s*items:\s*\[([\s\S]*?)\]\s*\}/g;
+        let match;
+        while ((match = categoryRegex.exec(content)) !== null) {
+            const label = match[1];
+            const itemsStr = match[2];
+            const pageIds = extractPageIds(itemsStr);
+            groups.push({ label, pageIds });
+        }
+        // Match autogenerated: { type: 'autogenerated', dirName: 'x' }
+        const autoRegex = /\{\s*type:\s*['"]autogenerated['"],\s*dirName:\s*['"]([^'"]+)['"]\s*\}/g;
+        while ((match = autoRegex.exec(content)) !== null) {
+            const dirName = match[1];
+            const subDir = join(docsDir, dirName);
+            if (existsSync(subDir)) {
+                const files = findMdxFiles(subDir);
+                const pageIds = files.map(f => relative(docsDir, f).replace(/\.(md|mdx)$/, '').replace(/\\/g, '/'));
+                const label = dirName.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+                groups.push({ label, pageIds });
+            }
+        }
+        // Match top-level string references: 'intro', 'getting-started'
+        if (groups.length === 0) {
+            const stringRefs = content.match(/['"]([a-zA-Z0-9/_-]+)['"]/g);
+            if (stringRefs) {
+                const pageIds = stringRefs.map(s => s.replace(/['"]/g, '')).filter(s => !['category', 'doc', 'autogenerated'].includes(s));
+                if (pageIds.length > 0) {
+                    groups.push({ label: 'Documentation', pageIds });
+                }
+            }
+        }
+        return groups.length > 0 ? groups : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractPageIds(itemsStr) {
+    const ids = [];
+    // String shorthand: 'page-id'
+    const stringRegex = /['"]([a-zA-Z0-9/_-]+)['"]/g;
+    let match;
+    while ((match = stringRegex.exec(itemsStr)) !== null) {
+        const val = match[1];
+        if (!['doc', 'category', 'autogenerated'].includes(val)) {
+            ids.push(val);
+        }
+    }
+    return ids;
+}
+function walkDocsDirectory(docsDir) {
+    const groups = [];
+    // Root-level files
+    const rootFiles = getMdFilesInDir(docsDir);
+    if (rootFiles.length > 0) {
+        groups.push({ label: 'Documentation', files: rootFiles, position: 0 });
+    }
+    // Subdirectories
+    try {
+        const entries = readdirSync(docsDir);
+        for (const entry of entries) {
+            const fullPath = join(docsDir, entry);
+            if (!statSync(fullPath).isDirectory() || entry.startsWith('.') || entry === 'node_modules')
+                continue;
+            const files = findMdxFiles(fullPath);
+            if (files.length === 0)
+                continue;
+            // Read _category_.json for label and position
+            let label = entry.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+            let position = Infinity;
+            const categoryPath = join(fullPath, '_category_.json');
+            if (existsSync(categoryPath)) {
+                try {
+                    const cat = JSON.parse(readFileSync(categoryPath, 'utf-8'));
+                    if (cat.label)
+                        label = cat.label;
+                    if (typeof cat.position === 'number')
+                        position = cat.position;
+                }
+                catch { /* skip */ }
+            }
+            groups.push({ label, files: sortByWeight(files), position });
+        }
+    }
+    catch { /* skip */ }
+    return groups.sort((a, b) => a.position - b.position);
+}
+function getMdFilesInDir(dir) {
+    try {
+        return readdirSync(dir)
+            .filter(f => /\.(md|mdx)$/.test(f))
+            .map(f => join(dir, f));
+    }
+    catch {
+        return [];
+    }
+}
+function sortByWeight(files) {
+    return files.sort((a, b) => {
+        const aName = basename(a, extname(a)).toLowerCase();
+        const bName = basename(b, extname(b)).toLowerCase();
+        if (aName === 'index' || aName === 'readme')
+            return -1;
+        if (bName === 'index' || bName === 'readme')
+            return 1;
+        try {
+            const aWeight = getSortWeight(readFileSync(a, 'utf-8'));
+            const bWeight = getSortWeight(readFileSync(b, 'utf-8'));
+            if (aWeight !== bWeight)
+                return aWeight - bWeight;
+        }
+        catch { /* skip */ }
+        return aName.localeCompare(bName);
+    });
+}
+function collectStaticAssets(staticDir, result, stats) {
+    const imgExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico']);
+    const imageMapping = new Map();
+    function walk(dir) {
+        try {
+            for (const entry of readdirSync(dir)) {
+                const fullPath = join(dir, entry);
+                if (statSync(fullPath).isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (imgExts.has(extname(entry).toLowerCase())) {
+                    const rel = relative(staticDir, fullPath);
+                    const dest = `public/${rel}`;
+                    result.assets.set(dest, fullPath);
+                    imageMapping.set(`/static/${rel}`, `/${rel}`);
+                    imageMapping.set(`static/${rel}`, `/${rel}`);
+                    stats.images++;
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk(staticDir);
+    // Rewrite image paths
+    if (imageMapping.size > 0) {
+        for (const [path, content] of result.files) {
+            result.files.set(path, rewriteImagePaths(content, imageMapping));
+        }
+    }
+}
+function extractTitle(content, filePath) {
+    const fmMatch = content.match(/^---\n[\s\S]*?title:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
+    if (fmMatch)
+        return fmMatch[1].trim();
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match)
+        return h1Match[1].trim();
+    return basename(filePath, extname(filePath)).replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+function countNewOccurrences(original, transformed, marker) {
+    const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const origCount = (original.match(new RegExp(escaped, 'g')) || []).length;
+    const newCount = (transformed.match(new RegExp(escaped, 'g')) || []).length;
+    return Math.max(0, newCount - origCount);
+}
+function createEmptyResult(name) {
+    return {
+        navigation: [],
+        name: name || 'Documentation',
+        description: 'Imported from Docusaurus',
+        files: new Map(),
+        assets: new Map(),
+        warnings: [],
+        stats: { pages: 0, groups: 0, transforms: { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 } },
+        sourceFormat: 'docusaurus',
+    };
+}

package/dist/importers/gitbook.d.ts

@@ -0,0 +1,5 @@
+import type { ImportResult } from './types.js';
+/**
+ * Import GitBook documentation.
+ */
+export declare function importGitBook(dir: string, name?: string): ImportResult;

package/dist/importers/gitbook.js

@@ -0,0 +1,189 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, relative, basename, extname } from 'path';
+import { findMdxFiles } from '../utils/files.js';
+import { transformGitBookHints, transformGitBookTabs, transformGitBookSteps, transformGitBookExpandable, transformGitBookContentRef, transformGitBookEmbed, normalizeFrontmatter, rewriteImagePaths, } from './transform.js';
+/**
+ * Import GitBook documentation.
+ */
+export function importGitBook(dir, name) {
+    const result = createEmptyResult(name);
+    const stats = { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 };
+    // Check for .gitbook.yaml root config
+    let rootPath = '';
+    const gitbookYaml = join(dir, '.gitbook.yaml');
+    if (existsSync(gitbookYaml)) {
+        try {
+            const yamlContent = readFileSync(gitbookYaml, 'utf-8');
+            const rootMatch = yamlContent.match(/root:\s*(.+)/);
+            if (rootMatch)
+                rootPath = rootMatch[1].trim().replace(/^\.\//, '');
+        }
+        catch { /* skip */ }
+    }
+    const contentDir = rootPath ? join(dir, rootPath) : dir;
+    // Parse SUMMARY.md for navigation
+    const summaryPath = join(contentDir, 'SUMMARY.md');
+    if (existsSync(summaryPath)) {
+        const summaryContent = readFileSync(summaryPath, 'utf-8');
+        const groups = parseSummaryMd(summaryContent);
+        for (const group of groups) {
+            const pages = [];
+            for (const ref of group.pageRefs) {
+                const page = processGitBookPage(contentDir, ref.path, ref.title, stats, result);
+                if (page)
+                    pages.push(page);
+            }
+            if (pages.length > 0) {
+                result.navigation.push({ group: group.label, pages });
+            }
+        }
+    }
+    else {
+        // No SUMMARY.md — walk files
+        const files = findMdxFiles(contentDir);
+        const pages = [];
+        for (const filePath of files) {
+            if (basename(filePath).toUpperCase() === 'SUMMARY.MD')
+                continue;
+            const rel = relative(contentDir, filePath);
+            const page = processGitBookPage(contentDir, rel, undefined, stats, result);
+            if (page)
+                pages.push(page);
+        }
+        if (pages.length > 0) {
+            result.navigation.push({ group: 'Documentation', pages });
+        }
+    }
+    // Copy .gitbook/assets/
+    const assetsDir = join(dir, '.gitbook', 'assets');
+    if (existsSync(assetsDir)) {
+        collectGitBookAssets(assetsDir, result, stats);
+    }
+    result.stats = {
+        pages: result.files.size,
+        groups: result.navigation.length,
+        transforms: stats,
+    };
+    return result;
+}
+function parseSummaryMd(content) {
+    const groups = [];
+    let currentGroup = null;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        // Group headers: ## Group Name or non-indented text without link
+        const headerMatch = line.match(/^#{1,3}\s+(.+)/);
+        if (headerMatch) {
+            if (currentGroup && currentGroup.pageRefs.length > 0) {
+                groups.push(currentGroup);
+            }
+            currentGroup = { label: headerMatch[1].trim(), pageRefs: [] };
+            continue;
+        }
+        // Page references: * [Title](path.md) or - [Title](path.md)
+        const linkMatch = line.match(/^[\s]*[*-]\s+\[([^\]]+)\]\(([^)]+)\)/);
+        if (linkMatch) {
+            if (!currentGroup) {
+                currentGroup = { label: 'Documentation', pageRefs: [] };
+            }
+            currentGroup.pageRefs.push({ title: linkMatch[1], path: linkMatch[2] });
+        }
+    }
+    if (currentGroup && currentGroup.pageRefs.length > 0) {
+        groups.push(currentGroup);
+    }
+    // If no groups found, treat all links as one group
+    if (groups.length === 0) {
+        const allLinks = [];
+        const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+        let match;
+        while ((match = linkRegex.exec(content)) !== null) {
+            allLinks.push({ title: match[1], path: match[2] });
+        }
+        if (allLinks.length > 0) {
+            groups.push({ label: 'Documentation', pageRefs: allLinks });
+        }
+    }
+    return groups;
+}
+function processGitBookPage(contentDir, pagePath, title, stats, result) {
+    const filePath = join(contentDir, pagePath);
+    // Guard: prevent path traversal outside content directory
+    if (!filePath.startsWith(contentDir)) {
+        result.warnings.push(`Path traversal blocked: ${pagePath}`);
+        return null;
+    }
+    if (!existsSync(filePath)) {
+        result.warnings.push(`Page not found: ${pagePath}`);
+        return null;
+    }
+    let content = readFileSync(filePath, 'utf-8');
+    const originalContent = content;
+    // Apply all GitBook transforms
+    content = transformGitBookHints(content);
+    content = transformGitBookTabs(content);
+    content = transformGitBookSteps(content);
+    content = transformGitBookExpandable(content);
+    content = transformGitBookContentRef(content);
+    content = transformGitBookEmbed(content);
+    content = normalizeFrontmatter(content);
+    // Count transforms
+    stats.callouts += countNewOccurrences(originalContent, content, '<Callout');
+    stats.tabs += countNewOccurrences(originalContent, content, '<TabPanel');
+    stats.steps += countNewOccurrences(originalContent, content, '<Step>');
+    stats.accordions += countNewOccurrences(originalContent, content, '<Accordion');
+    const pageTitle = title || extractTitle(content, filePath);
+    const slug = pagePath.replace(/\.(md|mdx)$/, '').replace(/\\/g, '/');
+    const outputPath = `content/docs/${slug}.mdx`;
+    result.files.set(outputPath, content);
+    return { title: pageTitle, slug, sourcePath: pagePath, content };
+}
+function collectGitBookAssets(assetsDir, result, stats) {
+    const imageMapping = new Map();
+    try {
+        for (const entry of readdirSync(assetsDir)) {
+            const fullPath = join(assetsDir, entry);
+            if (statSync(fullPath).isFile()) {
+                const dest = `public/images/${entry}`;
+                result.assets.set(dest, fullPath);
+                imageMapping.set(`.gitbook/assets/${entry}`, `/images/${entry}`);
+                imageMapping.set(`../.gitbook/assets/${entry}`, `/images/${entry}`);
+                stats.images++;
+            }
+        }
+    }
+    catch { /* skip */ }
+    // Rewrite image paths
+    if (imageMapping.size > 0) {
+        for (const [path, content] of result.files) {
+            result.files.set(path, rewriteImagePaths(content, imageMapping));
+        }
+    }
+}
+function extractTitle(content, filePath) {
+    const fmMatch = content.match(/^---\n[\s\S]*?title:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
+    if (fmMatch)
+        return fmMatch[1].trim();
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match)
+        return h1Match[1].trim();
+    return basename(filePath, extname(filePath)).replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+function countNewOccurrences(original, transformed, marker) {
+    const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const origCount = (original.match(new RegExp(escaped, 'g')) || []).length;
+    const newCount = (transformed.match(new RegExp(escaped, 'g')) || []).length;
+    return Math.max(0, newCount - origCount);
+}
+function createEmptyResult(name) {
+    return {
+        navigation: [],
+        name: name || 'Documentation',
+        description: 'Imported from GitBook',
+        files: new Map(),
+        assets: new Map(),
+        warnings: [],
+        stats: { pages: 0, groups: 0, transforms: { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 } },
+        sourceFormat: 'gitbook',
+    };
+}

package/dist/importers/github.d.ts

@@ -0,0 +1,8 @@
+import type { ImportResult, ImportFormat } from './types.js';
+/**
+ * Fetch docs from a GitHub URL and import them.
+ */
+export declare function importFromGitHub(owner: string, repo: string, path: string, ref: string, options?: {
+    format?: ImportFormat;
+    name?: string;
+}): Promise<ImportResult>;

package/dist/importers/github.js

@@ -0,0 +1,99 @@
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join, extname } from 'path';
+import { tmpdir } from 'os';
+import { detectFormat } from './detect.js';
+import { runImport } from './index.js';
+// Only fetch text-based files for import
+const TEXT_EXTENSIONS = new Set([
+    '.md', '.mdx', '.json', '.yaml', '.yml', '.js', '.ts', '.txt',
+    '.html', '.htm', '.xml', '.css', '.toml', '.cfg', '.ini', '.rst',
+]);
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico']);
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB limit per file
+const MAX_DEPTH = 20; // Prevent unbounded recursion
+/**
+ * Fetch docs from a GitHub URL and import them.
+ */
+export async function importFromGitHub(owner, repo, path, ref, options) {
+    const token = process.env.GITHUB_TOKEN;
+    const headers = {
+        Accept: 'application/vnd.github.v3+json',
+        'User-Agent': 'skrypt-cli',
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const tempDir = join(tmpdir(), `skrypt-import-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    try {
+        console.log(`  Fetching from GitHub: ${owner}/${repo}/${path || ''}...`);
+        let fileCount = 0;
+        async function fetchDir(dirPath, localDir, depth) {
+            if (depth > MAX_DEPTH) {
+                console.warn(`  Warning: Max directory depth (${MAX_DEPTH}) reached, skipping deeper paths`);
+                return;
+            }
+            const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${dirPath}?ref=${ref}`;
+            const res = await fetch(apiUrl, { headers });
+            if (res.status === 403) {
+                const rateLimitRemaining = res.headers.get('X-RateLimit-Remaining');
+                if (rateLimitRemaining === '0') {
+                    const resetTime = res.headers.get('X-RateLimit-Reset');
+                    const resetDate = resetTime ? new Date(parseInt(resetTime) * 1000) : null;
+                    throw new Error(`GitHub API rate limit exceeded. ${!token ? 'Set GITHUB_TOKEN for higher limits. ' : ''}${resetDate ? `Resets at ${resetDate.toLocaleTimeString()}.` : ''}`);
+                }
+                throw new Error(`GitHub API forbidden: ${res.statusText}`);
+            }
+            if (!res.ok) {
+                throw new Error(`GitHub API error: ${res.status} ${res.statusText}`);
+            }
+            const entries = await res.json();
+            for (const entry of entries) {
+                if (entry.type === 'dir') {
+                    const subDir = join(localDir, entry.name);
+                    mkdirSync(subDir, { recursive: true });
+                    await fetchDir(entry.path, subDir, depth + 1);
+                }
+                else if (entry.type === 'file' && entry.download_url) {
+                    // Skip files that are too large
+                    if (entry.size && entry.size > MAX_FILE_SIZE) {
+                        console.warn(`  Skipping large file: ${entry.name} (${Math.round(entry.size / 1024)}KB)`);
+                        continue;
+                    }
+                    const ext = extname(entry.name).toLowerCase();
+                    const isText = TEXT_EXTENSIONS.has(ext);
+                    const isImage = IMAGE_EXTENSIONS.has(ext);
+                    if (!isText && !isImage)
+                        continue;
+                    const fileRes = await fetch(entry.download_url, { headers });
+                    if (fileRes.ok) {
+                        if (isImage) {
+                            // Fetch binary content properly for images
+                            const buffer = Buffer.from(await fileRes.arrayBuffer());
+                            writeFileSync(join(localDir, entry.name), buffer);
+                        }
+                        else {
+                            const content = await fileRes.text();
+                            writeFileSync(join(localDir, entry.name), content);
+                        }
+                        fileCount++;
+                        process.stdout.write(`\r  Fetched ${fileCount} files...`);
+                    }
+                }
+            }
+        }
+        await fetchDir(path, tempDir, 0);
+        console.log(`\r  Fetched ${fileCount} files from GitHub`);
+        const format = options?.format || detectFormat(tempDir);
+        return runImport(tempDir, format, options?.name);
+    }
+    finally {
+        // Clean up temp directory
+        try {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup
+        }
+    }
+}

package/dist/importers/index.d.ts

@@ -0,0 +1,15 @@
+export type { ImportFormat, ImportResult, ImportedGroup, ImportedPage, TransformStats } from './types.js';
+export { detectFormat, isGitHubUrl, parseGitHubUrl } from './detect.js';
+export { importMarkdown } from './markdown.js';
+export { importMintlify } from './mintlify.js';
+export { importDocusaurus } from './docusaurus.js';
+export { importGitBook } from './gitbook.js';
+export { importReadme } from './readme.js';
+export { importNotion } from './notion.js';
+export { importConfluence } from './confluence.js';
+export { importFromGitHub } from './github.js';
+import type { ImportFormat, ImportResult } from './types.js';
+/**
+ * Run the appropriate importer for a detected format.
+ */
+export declare function runImport(dir: string, format: ImportFormat, name?: string): ImportResult;

package/dist/importers/index.js

@@ -0,0 +1,30 @@
+export { detectFormat, isGitHubUrl, parseGitHubUrl } from './detect.js';
+export { importMarkdown } from './markdown.js';
+export { importMintlify } from './mintlify.js';
+export { importDocusaurus } from './docusaurus.js';
+export { importGitBook } from './gitbook.js';
+export { importReadme } from './readme.js';
+export { importNotion } from './notion.js';
+export { importConfluence } from './confluence.js';
+export { importFromGitHub } from './github.js';
+import { importMarkdown } from './markdown.js';
+import { importMintlify } from './mintlify.js';
+import { importDocusaurus } from './docusaurus.js';
+import { importGitBook } from './gitbook.js';
+import { importReadme } from './readme.js';
+import { importNotion } from './notion.js';
+import { importConfluence } from './confluence.js';
+/**
+ * Run the appropriate importer for a detected format.
+ */
+export function runImport(dir, format, name) {
+    switch (format) {
+        case 'mintlify': return importMintlify(dir, name);
+        case 'docusaurus': return importDocusaurus(dir, name);
+        case 'gitbook': return importGitBook(dir, name);
+        case 'readme': return importReadme(dir, name);
+        case 'notion': return importNotion(dir, name);
+        case 'confluence': return importConfluence(dir, name);
+        case 'markdown': return importMarkdown(dir, name);
+    }
+}

package/dist/importers/markdown.d.ts

@@ -0,0 +1,6 @@
+import type { ImportResult } from './types.js';
+/**
+ * Import plain Markdown/MDX directory.
+ * Folder structure → groups, files → pages.
+ */
+export declare function importMarkdown(dir: string, name?: string): ImportResult;