skrypt-ai 0.4.1 → 0.5.0

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;

package/dist/importers/readme.js

@@ -0,0 +1,184 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, relative, basename, extname } from 'path';
+import { findMdxFiles } from '../utils/files.js';
+import { transformReadmeCallouts, transformReadmeCodeBlocks, normalizeFrontmatter, } from './transform.js';
+/**
+ * Import ReadMe.io documentation export.
+ */
+export function importReadme(dir, name) {
+    const result = createEmptyResult(name);
+    const stats = { callouts: 0, tabs: 0, codeGroups: 0, steps: 0, accordions: 0, images: 0, other: 0 };
+    // ReadMe organizes by category folders with _order.yaml
+    const categories = discoverCategories(dir);
+    for (const category of categories) {
+        const pages = [];
+        for (const file of category.files) {
+            const page = processReadmePage(dir, file, stats, result);
+            if (page)
+                pages.push(page);
+        }
+        if (pages.length > 0) {
+            result.navigation.push({ group: category.label, pages });
+        }
+    }
+    // Handle CDN images (files.readme.io)
+    flagCdnImages(result, stats);
+    result.stats = {
+        pages: result.files.size,
+        groups: result.navigation.length,
+        transforms: stats,
+    };
+    return result;
+}
+function discoverCategories(dir) {
+    const categories = [];
+    // Check for category subdirectories
+    try {
+        const entries = readdirSync(dir);
+        const hasSubdirs = entries.some(e => {
+            try {
+                return statSync(join(dir, e)).isDirectory() && !e.startsWith('.');
+            }
+            catch {
+                return false;
+            }
+        });
+        if (hasSubdirs) {
+            for (const entry of entries) {
+                const fullPath = join(dir, entry);
+                try {
+                    if (!statSync(fullPath).isDirectory() || entry.startsWith('.') || entry === 'node_modules')
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const files = findMdxFiles(fullPath);
+                if (files.length === 0)
+                    continue;
+                // Check _order.yaml
+                const orderPath = join(fullPath, '_order.yaml');
+                let orderedFiles = files;
+                const position = Infinity;
+                if (existsSync(orderPath)) {
+                    try {
+                        const orderContent = readFileSync(orderPath, 'utf-8');
+                        const order = orderContent.split('\n').map(l => l.replace(/^-\s*/, '').trim()).filter(Boolean);
+                        orderedFiles = orderFiles(files, order, fullPath);
+                    }
+                    catch { /* skip */ }
+                }
+                else {
+                    orderedFiles = sortByFrontmatterOrder(files);
+                }
+                const label = entry.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+                categories.push({ label, files: orderedFiles, position });
+            }
+        }
+        else {
+            // Flat structure — all files in root
+            const files = findMdxFiles(dir);
+            if (files.length > 0) {
+                categories.push({ label: 'Documentation', files: sortByFrontmatterOrder(files), position: 0 });
+            }
+        }
+    }
+    catch { /* skip */ }
+    return categories.sort((a, b) => a.position - b.position);
+}
+function orderFiles(files, order, _dir) {
+    const ordered = [];
+    for (const slug of order) {
+        const match = files.find(f => {
+            const name = basename(f, extname(f));
+            return name === slug || name.toLowerCase() === slug.toLowerCase();
+        });
+        if (match)
+            ordered.push(match);
+    }
+    // Add remaining files not in order
+    for (const f of files) {
+        if (!ordered.includes(f))
+            ordered.push(f);
+    }
+    return ordered;
+}
+function sortByFrontmatterOrder(files) {
+    return [...files].sort((a, b) => {
+        try {
+            const aContent = readFileSync(a, 'utf-8');
+            const bContent = readFileSync(b, 'utf-8');
+            const aOrder = extractFmField(aContent, 'order');
+            const bOrder = extractFmField(bContent, 'order');
+            const aNum = aOrder !== null ? Number(aOrder) : Infinity;
+            const bNum = bOrder !== null ? Number(bOrder) : Infinity;
+            if (aNum !== bNum)
+                return aNum - bNum;
+        }
+        catch { /* skip */ }
+        return basename(a).localeCompare(basename(b));
+    });
+}
+function extractFmField(content, field) {
+    const match = content.match(new RegExp(`^---\\n[\\s\\S]*?${field}:\\s*([^\\n]+)\\n[\\s\\S]*?---`, 'm'));
+    return match ? match[1].trim() : null;
+}
+function processReadmePage(dir, filePath, stats, result) {
+    let content = readFileSync(filePath, 'utf-8');
+    const originalContent = content;
+    // Apply ReadMe transforms
+    content = transformReadmeCallouts(content);
+    content = transformReadmeCodeBlocks(content);
+    // Map ReadMe-specific frontmatter
+    content = content.replace(/^---\n([\s\S]*?)\n---/, (match, fmStr) => {
+        const mapped = fmStr.replace(/^excerpt:\s*/m, 'description: ');
+        return `---\n${mapped}\n---`;
+    });
+    content = normalizeFrontmatter(content);
+    stats.callouts += countNew(originalContent, content, '<Callout');
+    stats.codeGroups += countNew(originalContent, content, '<CodeGroup');
+    const title = extractTitle(content, filePath);
+    const rel = relative(dir, filePath);
+    const slug = rel.replace(/\.(md|mdx)$/, '').replace(/\\/g, '/');
+    const outputPath = `content/docs/${slug}.mdx`;
+    result.files.set(outputPath, content);
+    return { title, slug, sourcePath: rel, content };
+}
+function flagCdnImages(result, stats) {
+    for (const [, content] of result.files) {
+        const cdnMatches = content.match(/https?:\/\/files\.readme\.io\/[^\s)]+/g);
+        if (cdnMatches) {
+            for (const url of cdnMatches) {
+                result.warnings.push(`CDN image found (manual download needed): ${url}`);
+                stats.images++;
+            }
+        }
+    }
+}
+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 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 ReadMe',
+        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: 'readme',
+    };
+}