skrypt-ai 0.4.2 → 0.6.0

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;

package/dist/importers/markdown.js

@@ -0,0 +1,105 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, relative, dirname, basename, extname } from 'path';
+import { findMdxFiles } from '../utils/files.js';
+import { normalizeFrontmatter, getSortWeight } from './transform.js';
+/**
+ * Import plain Markdown/MDX directory.
+ * Folder structure → groups, files → pages.
+ */
+export function importMarkdown(dir, name) {
+    const files = findMdxFiles(dir);
+    const result = createEmptyResult('markdown', name);
+    const stats = { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 };
+    if (files.length === 0) {
+        result.warnings.push('No .md or .mdx files found');
+        return result;
+    }
+    // Group files by directory
+    const grouped = new Map();
+    for (const filePath of files) {
+        const rel = relative(dir, filePath);
+        const dirName = dirname(rel);
+        const group = dirName === '.' ? 'Documentation' : dirName.split('/')[0];
+        if (!grouped.has(group))
+            grouped.set(group, []);
+        grouped.get(group).push({ path: filePath, content: readFileSync(filePath, 'utf-8') });
+    }
+    // Build navigation
+    for (const [groupName, groupFiles] of grouped) {
+        const pages = [];
+        // Sort: index/README first, then by frontmatter order, then alphabetical
+        const sorted = groupFiles.sort((a, b) => {
+            const aName = basename(a.path, extname(a.path)).toLowerCase();
+            const bName = basename(b.path, extname(b.path)).toLowerCase();
+            if (aName === 'index' || aName === 'readme')
+                return -1;
+            if (bName === 'index' || bName === 'readme')
+                return 1;
+            const aWeight = getSortWeight(a.content);
+            const bWeight = getSortWeight(b.content);
+            if (aWeight !== bWeight)
+                return aWeight - bWeight;
+            return aName.localeCompare(bName);
+        });
+        for (const file of sorted) {
+            const rel = relative(dir, file.path);
+            const slug = rel.replace(/\.(md|mdx)$/, '').replace(/\\/g, '/');
+            const title = extractTitle(file.content, file.path);
+            const transformed = normalizeFrontmatter(file.content, { title });
+            const outputPath = `content/docs/${slug}.mdx`;
+            pages.push({ title, slug, sourcePath: rel, content: transformed });
+            result.files.set(outputPath, transformed);
+            // Track images
+            const imgMatches = transformed.match(/!\[.*?\]\(([^)]+)\)/g);
+            if (imgMatches) {
+                for (const imgMatch of imgMatches) {
+                    const src = imgMatch.match(/!\[.*?\]\(([^)]+)\)/)?.[1];
+                    if (src && !src.startsWith('http')) {
+                        const srcPath = join(dir, dirname(rel), src);
+                        if (existsSync(srcPath)) {
+                            const destPath = `public/images/${basename(src)}`;
+                            result.assets.set(destPath, srcPath);
+                            stats.images++;
+                        }
+                    }
+                }
+            }
+        }
+        result.navigation.push({ group: titleCase(groupName), pages });
+    }
+    result.stats = {
+        pages: result.files.size,
+        groups: result.navigation.length,
+        transforms: stats,
+    };
+    return result;
+}
+function extractTitle(content, filePath) {
+    // Try frontmatter title
+    const fmMatch = content.match(/^---\n[\s\S]*?title:\s*["']?([^"'\n]+)["']?\s*\n[\s\S]*?---/m);
+    if (fmMatch)
+        return fmMatch[1].trim();
+    // Try first H1
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match)
+        return h1Match[1].trim();
+    // Fallback to filename
+    return titleCase(basename(filePath, extname(filePath)).replace(/[-_]/g, ' '));
+}
+function titleCase(str) {
+    return str
+        .replace(/[-_]/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+}
+function createEmptyResult(format, name) {
+    return {
+        navigation: [],
+        name: name || 'Documentation',
+        description: 'Imported documentation',
+        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: format,
+    };
+}

package/dist/importers/mintlify.d.ts

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

package/dist/importers/mintlify.js

@@ -0,0 +1,172 @@
+import { readFileSync, existsSync } from 'fs';
+import { join, relative, basename, extname } from 'path';
+import { findMdxFiles } from '../utils/files.js';
+import { transformMintlifyCallouts, transformMintlifyTabs, normalizeFrontmatter, rewriteImagePaths } from './transform.js';
+/**
+ * Import Mintlify documentation.
+ */
+export function importMintlify(dir, name) {
+    const result = createEmptyResult(name);
+    const stats = { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 };
+    // Load config
+    const config = loadMintlifyConfig(dir);
+    if (!config) {
+        result.warnings.push('Could not parse mint.json or docs.json');
+        return result;
+    }
+    result.name = config.name || name || 'Documentation';
+    result.description = config.description || 'Imported from Mintlify';
+    // Process navigation
+    if (config.navigation) {
+        for (const navGroup of config.navigation) {
+            const pages = [];
+            for (const pageRef of navGroup.pages) {
+                if (typeof pageRef === 'string') {
+                    const page = processPage(dir, pageRef, stats, result);
+                    if (page)
+                        pages.push(page);
+                }
+                else if (typeof pageRef === 'object' && pageRef.pages) {
+                    // Nested group — flatten into pages with prefix
+                    for (const nestedPage of pageRef.pages) {
+                        if (typeof nestedPage === 'string') {
+                            const page = processPage(dir, nestedPage, stats, result);
+                            if (page)
+                                pages.push(page);
+                        }
+                    }
+                }
+            }
+            if (pages.length > 0) {
+                result.navigation.push({ group: navGroup.group, pages });
+            }
+        }
+    }
+    else {
+        // No navigation config — walk files
+        const files = findMdxFiles(dir);
+        const pages = [];
+        for (const filePath of files) {
+            const rel = relative(dir, filePath).replace(/\\/g, '/').replace(/\.(md|mdx)$/, '');
+            const page = processPage(dir, rel, stats, result);
+            if (page)
+                pages.push(page);
+        }
+        if (pages.length > 0) {
+            result.navigation.push({ group: 'Documentation', pages });
+        }
+    }
+    // Copy images
+    collectImages(dir, result, stats);
+    result.stats = {
+        pages: result.files.size,
+        groups: result.navigation.length,
+        transforms: stats,
+    };
+    return result;
+}
+function processPage(dir, pageRef, stats, result) {
+    // Find file (try .mdx first, then .md)
+    let filePath = join(dir, `${pageRef}.mdx`);
+    if (!existsSync(filePath)) {
+        filePath = join(dir, `${pageRef}.md`);
+    }
+    if (!existsSync(filePath)) {
+        result.warnings.push(`Page not found: ${pageRef}`);
+        return null;
+    }
+    let content = readFileSync(filePath, 'utf-8');
+    // Handle <Snippet file="x.mdx" /> — inline referenced files
+    content = content.replace(/<Snippet\s+file="([^"]+)"\s*\/>/g, (_match, snippetPath) => {
+        const snippetFile = join(dir, snippetPath);
+        // Guard: prevent path traversal outside source directory
+        if (!snippetFile.startsWith(dir)) {
+            result.warnings.push(`Snippet path traversal blocked: ${snippetPath}`);
+            return `<!-- Snippet blocked: ${snippetPath} -->`;
+        }
+        if (existsSync(snippetFile)) {
+            return readFileSync(snippetFile, 'utf-8');
+        }
+        result.warnings.push(`Snippet not found: ${snippetPath}`);
+        return `<!-- Snippet not found: ${snippetPath} -->`;
+    });
+    // Apply transforms
+    const originalContent = content;
+    content = transformMintlifyCallouts(content);
+    content = transformMintlifyTabs(content);
+    content = normalizeFrontmatter(content);
+    // Count transforms
+    stats.callouts += countDiff(originalContent, content, '<Callout');
+    stats.tabs += countDiff(originalContent, content, '<TabPanel');
+    const title = extractTitle(content, filePath);
+    const slug = pageRef.replace(/\\/g, '/');
+    const outputPath = `content/docs/${slug}.mdx`;
+    result.files.set(outputPath, content);
+    return { title, slug, sourcePath: relative(dir, filePath), content };
+}
+function collectImages(dir, result, stats) {
+    // Scan all processed files for image references
+    const imageMapping = new Map();
+    for (const [, content] of result.files) {
+        const imgMatches = content.matchAll(/!\[.*?\]\(([^)]+)\)/g);
+        for (const match of imgMatches) {
+            const src = match[1];
+            if (src && !src.startsWith('http')) {
+                const srcPath = join(dir, src);
+                if (existsSync(srcPath)) {
+                    const destPath = `/images/${basename(src)}`;
+                    result.assets.set(`public${destPath}`, srcPath);
+                    imageMapping.set(src, destPath);
+                    stats.images++;
+                }
+            }
+        }
+    }
+    // Rewrite image paths in all files
+    if (imageMapping.size > 0) {
+        for (const [path, content] of result.files) {
+            result.files.set(path, rewriteImagePaths(content, imageMapping));
+        }
+    }
+}
+function loadMintlifyConfig(dir) {
+    for (const configName of ['mint.json', 'docs.json']) {
+        const configPath = join(dir, configName);
+        if (existsSync(configPath)) {
+            try {
+                return JSON.parse(readFileSync(configPath, 'utf-8'));
+            }
+            catch { /* try next */ }
+        }
+    }
+    return null;
+}
+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 countDiff(original, transformed, marker) {
+    const origCount = (original.match(new RegExp(escapeRegex(marker), 'g')) || []).length;
+    const newCount = (transformed.match(new RegExp(escapeRegex(marker), 'g')) || []).length;
+    return Math.max(0, newCount - origCount);
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function createEmptyResult(name) {
+    return {
+        navigation: [],
+        name: name || 'Documentation',
+        description: 'Imported from Mintlify',
+        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: 'mintlify',
+    };
+}

package/dist/importers/notion.d.ts

@@ -0,0 +1,5 @@
+import type { ImportResult } from './types.js';
+/**
+ * Import Notion export (extracted folder with UUID-named files).
+ */
+export declare function importNotion(dir: string, name?: string): ImportResult;

package/dist/importers/notion.js

@@ -0,0 +1,174 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative, basename, extname } from 'path';
+import { transformNotionCallouts, transformNotionToggles, normalizeFrontmatter, stripNotionUUIDs, } from './transform.js';
+/**
+ * Import Notion export (extracted folder with UUID-named files).
+ */
+export function importNotion(dir, name) {
+    const result = createEmptyResult(name);
+    const stats = { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 };
+    // Walk the export directory
+    const groups = discoverGroups(dir);
+    for (const group of groups) {
+        const pages = [];
+        for (const file of group.files) {
+            const page = processNotionPage(dir, file, stats, result);
+            if (page)
+                pages.push(page);
+        }
+        if (pages.length > 0) {
+            result.navigation.push({ group: group.label, pages });
+        }
+    }
+    // Copy images (strip UUIDs from filenames)
+    collectNotionImages(dir, result, stats);
+    result.stats = {
+        pages: result.files.size,
+        groups: result.navigation.length,
+        transforms: stats,
+    };
+    return result;
+}
+function discoverGroups(dir) {
+    const groups = [];
+    // Root-level markdown files
+    const rootFiles = [];
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        try {
+            if (statSync(fullPath).isFile() && /\.(md|mdx)$/.test(entry)) {
+                rootFiles.push(fullPath);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (rootFiles.length > 0) {
+        groups.push({ label: 'Documentation', files: rootFiles });
+    }
+    // Subdirectories (Notion exports create folders for sub-pages)
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        try {
+            if (!statSync(fullPath).isDirectory() || entry.startsWith('.'))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const mdFiles = findMdFilesRecursive(fullPath);
+        if (mdFiles.length === 0)
+            continue;
+        // Clean UUID from folder name
+        const cleanName = stripNotionUUIDs(entry)
+            .replace(/[-_]/g, ' ')
+            .replace(/\b\w/g, c => c.toUpperCase())
+            .trim();
+        groups.push({ label: cleanName || entry, files: mdFiles });
+    }
+    return groups;
+}
+function findMdFilesRecursive(dir) {
+    const files = [];
+    try {
+        for (const entry of readdirSync(dir)) {
+            const fullPath = join(dir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory() && !entry.startsWith('.')) {
+                    files.push(...findMdFilesRecursive(fullPath));
+                }
+                else if (stat.isFile() && /\.(md|mdx)$/.test(entry)) {
+                    files.push(fullPath);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { /* skip */ }
+    return files;
+}
+function processNotionPage(dir, filePath, stats, result) {
+    let content = readFileSync(filePath, 'utf-8');
+    const originalContent = content;
+    // Apply Notion transforms
+    content = transformNotionCallouts(content);
+    content = transformNotionToggles(content);
+    content = normalizeFrontmatter(content);
+    stats.callouts += countNew(originalContent, content, '<Callout');
+    stats.accordions += countNew(originalContent, content, '<Accordion');
+    const rel = relative(dir, filePath);
+    const cleanFilename = stripNotionUUIDs(rel.replace(/\.(md|mdx)$/, '')).replace(/\\/g, '/');
+    const slug = cleanFilename.toLowerCase().replace(/[^a-z0-9/]+/g, '-').replace(/^-|-$/g, '');
+    const title = extractTitle(content, filePath);
+    const outputPath = `content/docs/${slug}.mdx`;
+    result.files.set(outputPath, content);
+    return { title, slug, sourcePath: rel, content };
+}
+function collectNotionImages(dir, result, stats) {
+    const imgExts = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp']);
+    function walk(currentDir) {
+        try {
+            for (const entry of readdirSync(currentDir)) {
+                const fullPath = join(currentDir, entry);
+                try {
+                    const stat = statSync(fullPath);
+                    if (stat.isDirectory()) {
+                        walk(fullPath);
+                    }
+                    else if (imgExts.has(extname(entry).toLowerCase())) {
+                        const cleanName = stripNotionUUIDs(basename(entry, extname(entry))) + extname(entry);
+                        const dest = `public/images/${cleanName}`;
+                        result.assets.set(dest, fullPath);
+                        // Rewrite paths in content
+                        const origRef = relative(dir, fullPath);
+                        for (const [path, content] of result.files) {
+                            if (content.includes(origRef) || content.includes(entry)) {
+                                result.files.set(path, content.replaceAll(origRef, `/images/${cleanName}`).replaceAll(entry, `/images/${cleanName}`));
+                            }
+                        }
+                        stats.images++;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk(dir);
+}
+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();
+    // Strip UUID from filename for title
+    const cleanName = stripNotionUUIDs(basename(filePath, extname(filePath)));
+    return cleanName.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase()).trim();
+}
+function countNew(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 Notion',
+        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: 'notion',
+    };
+}

package/dist/importers/readme.d.ts

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