skrypt-ai 0.4.2 → 0.6.0

package/dist/importers/detect.js

@@ -0,0 +1,121 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, extname } from 'path';
+/**
+ * Auto-detect documentation format from a directory by checking marker files.
+ * First match wins (priority order).
+ */
+export function detectFormat(dir) {
+    // 1. Mintlify: mint.json or docs.json with Mintlify structure
+    if (existsSync(join(dir, 'mint.json')))
+        return 'mintlify';
+    if (existsSync(join(dir, 'docs.json'))) {
+        try {
+            const content = JSON.parse(readFileSync(join(dir, 'docs.json'), 'utf-8'));
+            // Mintlify docs.json has navigation with group/pages AND one of: anchors, tabs, topbarCtaButton
+            if (content.navigation && Array.isArray(content.navigation) &&
+                (content.anchors || content.tabs || content.topbarCtaButton || content.topbarLinks)) {
+                return 'mintlify';
+            }
+        }
+        catch { /* not mintlify */ }
+    }
+    // 2. Docusaurus: docusaurus.config.js or .ts
+    if (existsSync(join(dir, 'docusaurus.config.js')) || existsSync(join(dir, 'docusaurus.config.ts'))) {
+        return 'docusaurus';
+    }
+    // 3. GitBook: SUMMARY.md or .gitbook.yaml
+    if (existsSync(join(dir, 'SUMMARY.md')) || existsSync(join(dir, '.gitbook.yaml'))) {
+        return 'gitbook';
+    }
+    // 4. ReadMe: files with [block: syntax or _order.yaml
+    if (hasReadmeMarkers(dir))
+        return 'readme';
+    // 5. Notion: files with <aside> + 32-char hex UUID filenames
+    if (hasNotionMarkers(dir))
+        return 'notion';
+    // 6. Confluence: .html files with <ac:structured-macro
+    if (hasConfluenceMarkers(dir))
+        return 'confluence';
+    // 7. MkDocs (handled by markdown importer)
+    if (existsSync(join(dir, 'mkdocs.yml')))
+        return 'markdown';
+    // 8. Fallback: any .md/.mdx files present
+    return 'markdown';
+}
+function hasReadmeMarkers(dir) {
+    try {
+        const entries = readdirSync(dir, { recursive: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            if (entry === '_order.yaml' || entry.endsWith('/_order.yaml'))
+                return true;
+            if (extname(entry) === '.md') {
+                try {
+                    const content = readFileSync(fullPath, 'utf-8');
+                    if (content.includes('[block:'))
+                        return true;
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch { /* skip */ }
+    return false;
+}
+function hasNotionMarkers(dir) {
+    const UUID_PATTERN = /[0-9a-f]{32}/;
+    try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            if (extname(entry) === '.md' && UUID_PATTERN.test(entry)) {
+                try {
+                    const content = readFileSync(join(dir, entry), 'utf-8');
+                    if (content.includes('<aside>'))
+                        return true;
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch { /* skip */ }
+    return false;
+}
+function hasConfluenceMarkers(dir) {
+    try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            if (extname(entry) === '.html') {
+                try {
+                    const content = readFileSync(join(dir, entry), 'utf-8');
+                    if (content.includes('<ac:structured-macro'))
+                        return true;
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    catch { /* skip */ }
+    return false;
+}
+/**
+ * Check if a string is a GitHub URL
+ */
+export function isGitHubUrl(input) {
+    return /^https?:\/\/(www\.)?github\.com\//.test(input);
+}
+/**
+ * Parse a GitHub URL into components
+ * Supports: https://github.com/owner/repo/tree/branch/path
+ */
+export function parseGitHubUrl(url) {
+    const match = url.match(/^https?:\/\/(www\.)?github\.com\/([^/]+)\/([^/]+)(?:\/tree\/([^/]+)(?:\/(.*))?)?/);
+    if (!match) {
+        throw new Error(`Invalid GitHub URL: ${url}`);
+    }
+    return {
+        owner: match[2],
+        repo: match[3],
+        ref: match[4] || 'main',
+        path: match[5] || '',
+    };
+}

package/dist/importers/docusaurus.d.ts

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

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>;