skrypt-ai 0.4.2 → 0.6.0

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',
+    };
+}

package/dist/importers/transform.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Mintlify: <Note>content</Note>, <Warning>, <Tip>, <Info>, <Check>
+ */
+export declare function transformMintlifyCallouts(content: string): string;
+/**
+ * Docusaurus: :::note[Title]\ncontent\n:::
+ */
+export declare function transformDocusaurusAdmonitions(content: string): string;
+/**
+ * GitBook: {% hint style="info" %}\ncontent\n{% endhint %}
+ */
+export declare function transformGitBookHints(content: string): string;
+/**
+ * ReadMe RDMD: > 📘 Title\n> content lines
+ */
+export declare function transformReadmeCallouts(content: string): string;
+/**
+ * Notion: <aside>content</aside> and :::callout
+ */
+export declare function transformNotionCallouts(content: string): string;
+/**
+ * Confluence: <ac:structured-macro ac:name="info">...<ac:rich-text-body>content</ac:rich-text-body>
+ */
+export declare function transformConfluenceCallouts(content: string): string;
+/**
+ * Mintlify: <Tabs><Tab title="X">content</Tab></Tabs>
+ */
+export declare function transformMintlifyTabs(content: string): string;
+/**
+ * Docusaurus: <Tabs><TabItem value="x" label="X">content</TabItem></Tabs>
+ */
+export declare function transformDocusaurusTabs(content: string): string;
+/**
+ * GitBook: {% tabs %}{% tab title="X" %}content{% endtab %}{% endtabs %}
+ */
+export declare function transformGitBookTabs(content: string): string;
+/**
+ * ReadMe [block:code] JSON → <CodeGroup>
+ */
+export declare function transformReadmeCodeBlocks(content: string): string;
+/**
+ * GitBook: {% stepper %}{% step %}...{% endstep %}{% endstepper %}
+ */
+export declare function transformGitBookSteps(content: string): string;
+/**
+ * GitBook: {% expandable title="X" %}content{% endexpandable %}
+ */
+export declare function transformGitBookExpandable(content: string): string;
+/**
+ * GitBook: {% content-ref url="path" %} → markdown link
+ */
+export declare function transformGitBookContentRef(content: string): string;
+/**
+ * GitBook: {% embed url="..." %} → plain URL
+ */
+export declare function transformGitBookEmbed(content: string): string;
+/**
+ * Notion: <details><summary>Title</summary>content</details> → <Accordion>
+ */
+export declare function transformNotionToggles(content: string): string;
+/**
+ * Confluence: Convert common HTML and AC macros to markdown
+ */
+export declare function transformConfluenceHtml(content: string): string;
+/**
+ * Docusaurus: Strip import ... from '@theme/...' statements
+ */
+export declare function stripDocusaurusImports(content: string): string;
+interface FrontmatterDefaults {
+    title?: string;
+    description?: string;
+}
+/**
+ * Normalize frontmatter fields to Skrypt format
+ */
+export declare function normalizeFrontmatter(content: string, defaults?: FrontmatterDefaults): string;
+/**
+ * Rewrite image paths based on asset copy mapping
+ */
+export declare function rewriteImagePaths(content: string, mapping: Map<string, string>): string;
+/**
+ * Strip 32-char hex UUID suffixes from Notion filenames
+ * e.g., "Getting Started a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4.md" → "Getting Started.md"
+ */
+export declare function stripNotionUUIDs(filename: string): string;
+/**
+ * Get sorting weight from frontmatter
+ */
+export declare function getSortWeight(content: string): number;
+export {};