skrypt-ai 0.6.1 → 0.8.0

package/dist/structure/planner.js

@@ -0,0 +1,180 @@
+/**
+ * Use LLM to plan a smart documentation structure
+ */
+export async function planStructure(elements, topology, client) {
+    // Build a summary of the API surface for the LLM
+    const summary = buildAPISummary(elements, topology);
+    const response = await client.complete({
+        messages: [
+            {
+                role: 'system',
+                content: STRUCTURE_PLANNER_PROMPT,
+            },
+            {
+                role: 'user',
+                content: summary,
+            },
+        ],
+        temperature: 0,
+        maxTokens: 4096,
+    });
+    return parseStructurePlan(response.content, elements);
+}
+const STRUCTURE_PLANNER_PROMPT = `You are an expert documentation architect. Given a list of API elements, plan a documentation structure organized by user journey — NOT by file.
+
+## Output Structure
+
+Return a JSON object with this shape:
+\`\`\`json
+{
+  "pages": [
+    {
+      "slug": "quickstart",
+      "title": "Quickstart",
+      "category": "quickstart",
+      "description": "Get from zero to first API call in 5 minutes",
+      "elementNames": ["createClient", "configure"]
+    },
+    {
+      "slug": "authentication",
+      "title": "Authentication",
+      "category": "concepts",
+      "description": "How auth works — API keys, OAuth, sessions",
+      "elementNames": ["authenticate", "refreshToken", "SessionManager"]
+    }
+  ]
+}
+\`\`\`
+
+## Rules
+1. ALWAYS start with a "quickstart" page covering entry points
+2. Group by CONCEPT (auth, data model, errors), not by file
+3. Put classes and their methods together on one page
+4. "api" category pages are per-class or per-module API reference
+5. "guides" are task-oriented: "Setting up webhooks", "Testing your integration"
+6. Keep slugs lowercase-kebab-case
+7. Every element must appear in exactly one page
+8. Return ONLY the JSON, no markdown fences, no explanation`;
+function buildAPISummary(elements, topology) {
+    let summary = `## API Surface (${elements.length} elements)\n\n`;
+    if (topology.entryPoints.length > 0) {
+        summary += `### Entry Points\n`;
+        for (const ep of topology.entryPoints) {
+            summary += `- ${ep.kind} \`${ep.name}\` (${ep.filePath})\n`;
+        }
+        summary += '\n';
+    }
+    summary += `### Public API (${topology.publicAPI.length} elements)\n`;
+    for (const el of topology.publicAPI.slice(0, 100)) {
+        const parent = el.parentClass ? ` (${el.parentClass})` : '';
+        summary += `- ${el.kind} \`${el.name}\`${parent}: ${el.signature.slice(0, 80)}\n`;
+    }
+    if (topology.publicAPI.length > 100) {
+        summary += `... and ${topology.publicAPI.length - 100} more\n`;
+    }
+    if (topology.classClusters.size > 0) {
+        summary += `\n### Classes (${topology.classClusters.size})\n`;
+        for (const [className, methods] of topology.classClusters) {
+            summary += `- \`${className}\` with methods: ${methods.map(m => m.name).join(', ')}\n`;
+        }
+    }
+    return summary;
+}
+/**
+ * Parse LLM response into DocStructure
+ */
+function parseStructurePlan(content, elements) {
+    // Extract JSON from response
+    let jsonStr = content.trim();
+    // Remove markdown fences if present
+    jsonStr = jsonStr.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonStr);
+    }
+    catch {
+        // Fallback: create a simple structure
+        return createFallbackStructure(elements);
+    }
+    // Map element names to actual elements (case-insensitive for LLM tolerance)
+    const elementByName = new Map();
+    const elementByNameLower = new Map();
+    for (const el of elements) {
+        elementByName.set(el.name, el);
+        elementByNameLower.set(el.name.toLowerCase(), el);
+    }
+    const pages = [];
+    const assignedElements = new Set();
+    for (const page of parsed.pages) {
+        const pageElements = [];
+        for (const name of page.elementNames || []) {
+            // Try exact match first, then case-insensitive
+            let el = elementByName.get(name);
+            if (!el) {
+                el = elementByNameLower.get(name.toLowerCase());
+                if (el) {
+                    console.log(`  Note: LLM returned "${name}", matched to "${el.name}" (case-insensitive)`);
+                }
+            }
+            if (el) {
+                pageElements.push(el);
+                assignedElements.add(el.name);
+            }
+            else {
+                console.log(`  Warning: LLM referenced unknown element "${name}" — skipping`);
+            }
+        }
+        const category = (['quickstart', 'concepts', 'guides', 'api'].includes(page.category)
+            ? page.category
+            : 'api');
+        pages.push({
+            slug: page.slug,
+            title: page.title,
+            category,
+            description: page.description,
+            elements: pageElements,
+        });
+    }
+    // Add unassigned elements to an "API Reference" catch-all
+    const unassigned = elements.filter(el => !assignedElements.has(el.name));
+    if (unassigned.length > 0) {
+        pages.push({
+            slug: 'api-reference',
+            title: 'API Reference',
+            category: 'api',
+            description: 'Complete API reference',
+            elements: unassigned,
+        });
+    }
+    // Build navigation
+    const navigation = buildNavigation(pages);
+    return { pages, navigation };
+}
+function createFallbackStructure(elements) {
+    const pages = [{
+            slug: 'api-reference',
+            title: 'API Reference',
+            category: 'api',
+            description: 'Complete API reference',
+            elements,
+        }];
+    return {
+        pages,
+        navigation: [{ title: 'API Reference', slug: 'api-reference' }],
+    };
+}
+function buildNavigation(pages) {
+    const categories = {
+        quickstart: { title: 'Getting Started', slug: '', children: [] },
+        concepts: { title: 'Concepts', slug: '', children: [] },
+        guides: { title: 'Guides', slug: '', children: [] },
+        api: { title: 'API Reference', slug: '', children: [] },
+    };
+    for (const page of pages) {
+        const cat = categories[page.category];
+        if (cat) {
+            cat.children.push({ title: page.title, slug: page.slug });
+        }
+    }
+    return Object.values(categories).filter(c => c.children.length > 0);
+}

package/dist/structure/topology.d.ts

@@ -0,0 +1,16 @@
+import { APIElement } from '../scanner/types.js';
+/**
+ * Analysis of a codebase's API surface
+ */
+export interface TopologyAnalysis {
+    entryPoints: APIElement[];
+    publicAPI: APIElement[];
+    internalElements: APIElement[];
+    classClusters: Map<string, APIElement[]>;
+    fileClusters: Map<string, APIElement[]>;
+}
+/**
+ * Analyze the topology of a set of API elements.
+ * Identifies entry points, public surface, class groupings, and file clusters.
+ */
+export declare function analyzeTopology(elements: APIElement[]): TopologyAnalysis;

package/dist/structure/topology.js

@@ -0,0 +1,49 @@
+/**
+ * Analyze the topology of a set of API elements.
+ * Identifies entry points, public surface, class groupings, and file clusters.
+ */
+export function analyzeTopology(elements) {
+    const entryPoints = [];
+    const publicAPI = [];
+    const internalElements = [];
+    const classClusters = new Map();
+    const fileClusters = new Map();
+    for (const el of elements) {
+        // Classify by visibility
+        if (el.isExported || el.isPublic) {
+            publicAPI.push(el);
+        }
+        else {
+            internalElements.push(el);
+        }
+        // Identify likely entry points (exported top-level functions/classes)
+        if ((el.isExported || el.isPublic) && !el.parentClass && (el.kind === 'function' || el.kind === 'class')) {
+            // Heuristic: entry points are often in index.ts, main.ts, or have names like init, create, setup
+            const isEntryFile = /(?:index|main|app|server|client)\.\w+$/.test(el.filePath);
+            const isEntryName = /^(?:create|init|setup|configure|connect|start|build)/i.test(el.name);
+            if (isEntryFile || isEntryName) {
+                entryPoints.push(el);
+            }
+        }
+        // Group by parent class
+        if (el.parentClass) {
+            if (!classClusters.has(el.parentClass)) {
+                classClusters.set(el.parentClass, []);
+            }
+            classClusters.get(el.parentClass).push(el);
+        }
+        // Group by source file
+        const fileKey = el.filePath.replace(/\.(ts|js|py|go|rs|java|cs|php|kt|swift|rb)x?$/, '');
+        if (!fileClusters.has(fileKey)) {
+            fileClusters.set(fileKey, []);
+        }
+        fileClusters.get(fileKey).push(el);
+    }
+    return {
+        entryPoints,
+        publicAPI,
+        internalElements,
+        classClusters,
+        fileClusters,
+    };
+}

package/dist/structure/types.d.ts

@@ -0,0 +1,26 @@
+import { APIElement } from '../scanner/types.js';
+/**
+ * A planned page in the smart-structured docs
+ */
+export interface PagePlan {
+    slug: string;
+    title: string;
+    category: 'quickstart' | 'concepts' | 'guides' | 'api';
+    description: string;
+    elements: APIElement[];
+}
+/**
+ * Full documentation structure plan
+ */
+export interface DocStructure {
+    pages: PagePlan[];
+    navigation: NavigationNode[];
+}
+/**
+ * Navigation tree node
+ */
+export interface NavigationNode {
+    title: string;
+    slug: string;
+    children?: NavigationNode[];
+}

package/dist/template/docs.json

@@ -1,10 +1,13 @@
 {
   "name": "Skrypt",
   "description": "AI-powered documentation generation",
+  "fonts": {
+    "sans": "Inter",
+    "mono": "JetBrains Mono"
+  },
   "theme": {
     "primaryColor": "#3b82f6",
-    "accentColor": "#8b5cf6",
-    "font": "Inter"
+    "accentColor": "#8b5cf6"
   },
   "navigation": [
     {

package/dist/template/next.config.mjs

@@ -14,6 +14,37 @@ const withMDX = createMDX({
 const nextConfig = {
   pageExtensions: ['js', 'jsx', 'md', 'mdx', 'ts', 'tsx'],
   transpilePackages: ['@scalar/api-reference-react', '@scalar/api-reference'],
+  async headers() {
+    return [{
+      source: '/(.*)',
+      headers: [
+        {
+          key: 'Content-Security-Policy',
+          value: "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: https:; font-src 'self' data: https: https://fonts.gstatic.com; connect-src 'self' https:; frame-src 'self' https://codesandbox.io"
+        },
+        {
+          key: 'X-Frame-Options',
+          value: 'DENY'
+        },
+        {
+          key: 'X-Content-Type-Options',
+          value: 'nosniff'
+        },
+        {
+          key: 'Referrer-Policy',
+          value: 'strict-origin-when-cross-origin'
+        },
+        {
+          key: 'Strict-Transport-Security',
+          value: 'max-age=31536000; includeSubDomains'
+        },
+        {
+          key: 'Permissions-Policy',
+          value: 'camera=(), microphone=(), geolocation=()'
+        }
+      ]
+    }]
+  },
 }
 
 export default withMDX(nextConfig)

package/dist/template/package.json

@@ -13,16 +13,13 @@
     "@ai-sdk/anthropic": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
     "@ai-sdk/react": "^1.0.0",
-    "@codesandbox/sandpack-react": "^2.20.0",
     "@mdx-js/loader": "^3.1.0",
     "@mdx-js/react": "^3.1.0",
     "@next/mdx": "^15.3.0",
     "@orama/orama": "^3.1.0",
-    "@scalar/nextjs-api-reference": "^0.4.0",
     "clsx": "^2.1.0",
     "gray-matter": "^4.0.3",
     "lucide-react": "^0.500.0",
-    "mermaid": "^11.13.0",
     "next": "^15.3.0",
     "next-mdx-remote": "^6.0.0",
     "react": "^19.0.0",
@@ -35,6 +32,11 @@
     "tailwind-merge": "^3.0.0",
     "yaml": "^2.8.2"
   },
+  "optionalDependencies": {
+    "@codesandbox/sandpack-react": "^2.20.0",
+    "mermaid": "^11.13.0",
+    "@scalar/nextjs-api-reference": "^0.4.0"
+  },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.0",
     "@types/mdx": "^2.0.0",

package/dist/template/src/app/layout.tsx

@@ -5,12 +5,17 @@ import { SyntaxThemeProvider } from '@/contexts/syntax-theme'
 import { readFileSync } from 'fs'
 import { join } from 'path'
 import { derivePrimaryColors } from '@/lib/theme-utils'
+import { resolveFonts, buildGoogleFontsUrl } from '@/lib/fonts'
 
 const inter = Inter({ subsets: ['latin'] })
 
 function getDocsConfig() {
   const configPath = join(process.cwd(), 'docs.json')
-  return JSON.parse(readFileSync(configPath, 'utf-8'))
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf-8'))
+  } catch {
+    return {}
+  }
 }
 
 const docsConfig = getDocsConfig()
@@ -19,19 +24,13 @@ const siteName = docsConfig.name || 'Documentation'
 const siteDescription = docsConfig.description || 'Documentation'
 
 // Theme: derive primary color variants from docs.json
-const primaryHex = docsConfig.theme?.primaryColor || '#3b82f6'
+const rawColor = docsConfig.theme?.primaryColor
+const primaryHex = typeof rawColor === 'string' && /^#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?$/.test(rawColor) ? rawColor : '#3b82f6'
 const { primary, primaryDark, primaryLight, primaryForeground } = derivePrimaryColors(primaryHex)
 
-// Font: read from docs.json, default to Inter
-const customFont = docsConfig.theme?.font || 'Inter'
-const safeFont = customFont ? customFont.replace(/[^a-zA-Z0-9\s-]/g, '') : null
-const isCustomFont = safeFont !== 'Inter'
-const googleFontsUrl = isCustomFont
-  ? `https://fonts.googleapis.com/css2?family=${encodeURIComponent(safeFont!)}:wght@400;500;600;700;800&display=swap`
-  : null
-const googleFontsPreloadUrl = isCustomFont
-  ? `https://fonts.googleapis.com/css2?family=${encodeURIComponent(safeFont!)}:wght@400;600;700&display=swap`
-  : null
+// Fonts: read from docs.json (supports both new `fonts` key and legacy `theme.font`)
+const { sans, mono, needsGoogleFonts } = resolveFonts(docsConfig)
+const googleFontsUrl = needsGoogleFonts ? buildGoogleFontsUrl(sans, mono) : null
 
 // Build the CSS custom property overrides
 const themeStyles = `
@@ -40,7 +39,8 @@ const themeStyles = `
     --color-primary-dark: ${primaryDark};
     --color-primary-light: ${primaryLight};
     --color-primary-foreground: ${primaryForeground};
-    --font-body: "${safeFont}", "Inter", ui-sans-serif, system-ui, sans-serif;
+    --font-body: "${sans.name}", "Inter", ui-sans-serif, system-ui, sans-serif;
+    --font-mono: "${mono.name}", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
   }
 `
 

package/dist/template/src/app/llms-full.md/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server'
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+
+export async function GET() {
+  const paths = [
+    join(process.cwd(), 'content', 'docs', 'llms-full.md'),
+    join(process.cwd(), 'public', 'llms-full.md'),
+  ]
+
+  for (const path of paths) {
+    try {
+      const content = await readFile(path, 'utf-8')
+      return new NextResponse(content, {
+        headers: {
+          'Content-Type': 'text/markdown; charset=utf-8',
+          'Cache-Control': 'public, max-age=3600, s-maxage=86400',
+        },
+      })
+    } catch {
+      continue
+    }
+  }
+
+  return new NextResponse('# No llms-full.md found\n\nRun `skrypt generate` to create one.\n', {
+    status: 404,
+    headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+  })
+}

package/dist/template/src/app/llms.txt/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server'
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+
+export async function GET() {
+  const paths = [
+    join(process.cwd(), 'content', 'docs', 'llms.txt'),
+    join(process.cwd(), 'public', 'llms.txt'),
+  ]
+
+  for (const path of paths) {
+    try {
+      const content = await readFile(path, 'utf-8')
+      return new NextResponse(content, {
+        headers: {
+          'Content-Type': 'text/plain; charset=utf-8',
+          'Cache-Control': 'public, max-age=3600, s-maxage=86400',
+        },
+      })
+    } catch {
+      continue
+    }
+  }
+
+  return new NextResponse('# No llms.txt found\n\nRun `skrypt generate` to create one.\n', {
+    status: 404,
+    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+  })
+}

package/dist/template/src/app/md/[...slug]/route.ts

@@ -0,0 +1,174 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { readFile } from 'fs/promises'
+import { join, resolve } from 'path'
+
+/**
+ * Markdown route handler for content negotiation.
+ *
+ * Serves raw MDX/Markdown content with JSX components stripped,
+ * returning clean markdown that AI agents can consume directly.
+ */
+
+interface RouteParams {
+  params: Promise<{ slug: string[] }>
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  const { slug } = await params
+  const contentDir = resolve(process.cwd(), 'content', 'docs')
+
+  // Reject path traversal: slug segments must not contain .. or absolute paths
+  if (slug.some(s => s === '..' || s === '.' || s.includes('/') || s.includes('\\'))) {
+    return new NextResponse('# 400 Bad Request\n', {
+      status: 400,
+      headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+    })
+  }
+
+  // Try to find the MDX/MD source file
+  const filePath = join(contentDir, ...slug)
+
+  // Double-check resolved path stays within content directory
+  const resolved = resolve(filePath)
+  if (!resolved.startsWith(contentDir)) {
+    return new NextResponse('# 400 Bad Request\n', {
+      status: 400,
+      headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+    })
+  }
+  let content: string | null = null
+  let resolvedPath = ''
+
+  for (const ext of ['.mdx', '.md', '/index.mdx', '/index.md']) {
+    try {
+      resolvedPath = filePath + ext
+      content = await readFile(resolvedPath, 'utf-8')
+      break
+    } catch {
+      continue
+    }
+  }
+
+  if (!content) {
+    return new NextResponse('# 404 Not Found\n\nThis documentation page does not exist.\n', {
+      status: 404,
+      headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+    })
+  }
+
+  // Strip JSX components for clean markdown output
+  const markdown = stripMdxToMarkdown(content)
+
+  return new NextResponse(markdown, {
+    status: 200,
+    headers: {
+      'Content-Type': 'text/markdown; charset=utf-8',
+      'Cache-Control': 'public, max-age=3600, s-maxage=86400',
+      'X-Content-Source': 'mdx',
+    },
+  })
+}
+
+/**
+ * Lightweight MDX-to-markdown stripping for the route handler.
+ * Runs at request time so must be fast — uses regex, not a full parser.
+ */
+function stripMdxToMarkdown(mdx: string): string {
+  let out = mdx
+
+  // Remove import/export statements
+  out = out.replace(/^import\s+.*$/gm, '')
+  out = out.replace(/^export\s+(?!default\s).*$/gm, '')
+
+  // CodeGroup → flatten (keep code blocks)
+  out = out.replace(/<CodeGroup>\s*([\s\S]*?)\s*<\/CodeGroup>/g, (_m, inner: string) => inner.trim())
+
+  // Callout variants → blockquotes
+  for (const tag of ['Callout', 'Info', 'Warning', 'Success', 'Error', 'Tip', 'Note']) {
+    out = out.replace(
+      new RegExp(`<${tag}\\s+type=["']([^"']+)["'][^>]*>\\s*([\\s\\S]*?)\\s*<\\/${tag}>`, 'g'),
+      (_m, type: string, content: string) => {
+        const label = type.charAt(0).toUpperCase() + type.slice(1)
+        return `> **${label}:** ${content.trim()}\n`
+      }
+    )
+    out = out.replace(
+      new RegExp(`<${tag}(?:\\s[^>]*)?>\\s*([\\s\\S]*?)\\s*<\\/${tag}>`, 'g'),
+      (_m, content: string) => {
+        const label = tag === 'Callout' ? 'Note' : tag
+        return `> **${label}:** ${content.trim()}\n`
+      }
+    )
+  }
+
+  // CardGroup → unwrap
+  out = out.replace(/<CardGroup[^>]*>\s*/g, '')
+  out = out.replace(/\s*<\/CardGroup>/g, '')
+
+  // Card with href
+  out = out.replace(
+    /<Card\s+title=["']([^"']+)["']\s+(?:[^>]*?href=["']([^"']+)["'][^>]*?)>\s*([\s\S]*?)\s*<\/Card>/g,
+    (_m, title: string, href: string, desc: string) => {
+      const d = desc.trim().replace(/<[^>]+>/g, '')
+      return d ? `- **[${title}](${href})** — ${d}` : `- **[${title}](${href})**`
+    }
+  )
+
+  // Card without href
+  out = out.replace(
+    /<Card\s+title=["']([^"']+)["'][^>]*>\s*([\s\S]*?)\s*<\/Card>/g,
+    (_m, title: string, desc: string) => {
+      const d = desc.trim().replace(/<[^>]+>/g, '')
+      return d ? `- **${title}** — ${d}` : `- **${title}**`
+    }
+  )
+
+  // Tabs
+  out = out.replace(/<TabList>\s*([\s\S]*?)\s*<\/TabList>/g, '')
+  out = out.replace(/<Tab\s+label=["']([^"']+)["'][^>]*>\s*([\s\S]*?)\s*<\/Tab>/g,
+    (_m, label: string, content: string) => `#### ${label}\n\n${content.trim()}\n`
+  )
+  out = out.replace(/<TabPanel[^>]*>\s*([\s\S]*?)\s*<\/TabPanel>/g, (_m, c: string) => c.trim())
+  out = out.replace(/<Tabs[^>]*>\s*/g, '')
+  out = out.replace(/\s*<\/Tabs>/g, '')
+
+  // Steps
+  out = out.replace(/<Steps>\s*([\s\S]*?)\s*<\/Steps>/g, (_match, inner: string) => {
+    let n = 0
+    return inner.replace(
+      /<Step\s*(?:title=["']([^"']+)["'][^>]*)?>?\s*([\s\S]*?)\s*<\/Step>/g,
+      (_m, title: string | undefined, content: string) => {
+        n++
+        return `${n}. ${title ? `**${title}** ` : ''}${content.trim()}\n`
+      }
+    )
+  })
+
+  // Accordion
+  out = out.replace(/<AccordionGroup[^>]*>\s*/g, '')
+  out = out.replace(/\s*<\/AccordionGroup>/g, '')
+  out = out.replace(/<Accordion\s+title=["']([^"']+)["'][^>]*>\s*([\s\S]*?)\s*<\/Accordion>/g,
+    (_m, title: string, content: string) => `**${title}**\n\n${content.trim()}\n`
+  )
+
+  // Screenshot → image
+  out = out.replace(/<Screenshot\s+(?:[^>]*?src=["']([^"']+)["'][^>]*?)(?:\s+alt=["']([^"']+)["'])?[^>]*\s*\/?>/g,
+    (_m, src: string, alt?: string) => `![${alt || 'Screenshot'}](${src})`
+  )
+  out = out.replace(/<Screenshot\s+(?:[^>]*?src=["']([^"']+)["'][^>]*?)>[\s\S]*?<\/Screenshot>/g,
+    (_m, src: string) => `![Screenshot](${src})`
+  )
+
+  // Frame → unwrap
+  out = out.replace(/<Frame[^>]*>\s*/g, '')
+  out = out.replace(/\s*<\/Frame>/g, '')
+
+  // Catch-all: remove remaining JSX
+  out = out.replace(/<[A-Z][A-Za-z]*\s[^>]*\/>/g, '')
+  out = out.replace(/<[A-Z][A-Za-z]*(?:\s[^>]*)?>/g, '')
+  out = out.replace(/<\/[A-Z][A-Za-z]*>/g, '')
+
+  // Clean up
+  out = out.replace(/\n{4,}/g, '\n\n\n')
+  return out.trim() + '\n'
+}