@brainfish-ai/devdoc 0.1.41 → 0.1.43

package/renderer/app/llms-full.txt/route.js

@@ -0,0 +1,257 @@
+import { NextResponse } from 'next/server';
+import { join } from 'path';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import matter from 'gray-matter';
+/**
+ * llms-full.txt - Full documentation content for LLMs
+ * 
+ * Generated from docs.json configuration.
+ * Combines all documentation into a single file for LLM consumption.
+ */ const DOCS_DIR = join(process.cwd(), 'templates', 'starter');
+const BASE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'http://localhost:3000';
+function loadDocsConfig() {
+    const configPath = join(DOCS_DIR, 'docs.json');
+    if (!existsSync(configPath)) return null;
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return null;
+    }
+}
+function loadOpenAPISpec(specPath) {
+    const fullPath = join(DOCS_DIR, specPath);
+    if (!existsSync(fullPath)) return null;
+    try {
+        const content = readFileSync(fullPath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return null;
+    }
+}
+function getPageContent(slug) {
+    const extensions = [
+        '.mdx',
+        '.md'
+    ];
+    for (const ext of extensions){
+        const filePath = join(DOCS_DIR, `${slug}${ext}`);
+        if (existsSync(filePath)) {
+            try {
+                const fileContent = readFileSync(filePath, 'utf-8');
+                const { data, content } = matter(fileContent);
+                // Clean MDX content - remove JSX components
+                const cleanedContent = content.replace(/<[A-Z][a-zA-Z]*[^>]*\/>/g, '') // Self-closing JSX
+                .replace(/<[A-Z][a-zA-Z]*[^>]*>[\s\S]*?<\/[A-Z][a-zA-Z]*>/g, '') // JSX with children
+                .replace(/<!--[\s\S]*?-->/g, '') // HTML comments
+                .replace(/\n{3,}/g, '\n\n') // Extra blank lines
+                .trim();
+                return {
+                    title: data.title,
+                    description: data.description,
+                    content: cleanedContent
+                };
+            } catch  {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+function getChangelogFiles() {
+    const changelogDir = join(DOCS_DIR, 'changelog');
+    if (!existsSync(changelogDir)) return [];
+    try {
+        return readdirSync(changelogDir).filter((f)=>(f.endsWith('.mdx') || f.endsWith('.md')) && f !== 'latest.mdx').map((f)=>f.replace(/\.(mdx?|md)$/, '')).sort().reverse();
+    } catch  {
+        return [];
+    }
+}
+function generateDocsContent(tab, lines) {
+    lines.push(`# ${tab.tab}`);
+    lines.push('');
+    if (tab.groups) {
+        for (const group of tab.groups){
+            lines.push(`## ${group.group}`);
+            lines.push('');
+            for (const page of group.pages){
+                const pageData = getPageContent(page);
+                if (pageData) {
+                    lines.push(`### ${pageData.title || page}`);
+                    lines.push('');
+                    if (pageData.description) {
+                        lines.push(`> ${pageData.description}`);
+                        lines.push('');
+                    }
+                    const urlPath = page === 'index' ? '' : page;
+                    lines.push(`URL: ${BASE_URL}/#${tab.tab.toLowerCase()}/page/${urlPath}`);
+                    lines.push('');
+                    if (pageData.content) {
+                        lines.push(pageData.content);
+                        lines.push('');
+                    }
+                    lines.push('---');
+                    lines.push('');
+                }
+            }
+        }
+    }
+}
+function generateOpenAPIContent(tab, lines) {
+    lines.push(`# ${tab.tab}`);
+    lines.push('');
+    if (tab.versions && tab.versions.length > 0) {
+        for (const version of tab.versions){
+            const spec = loadOpenAPISpec(version.spec);
+            if (!spec) continue;
+            const versionLabel = version.default ? `${version.version} (current)` : version.version;
+            lines.push(`## ${versionLabel}`);
+            lines.push('');
+            if (spec.info?.title) {
+                lines.push(`**${spec.info.title}**`);
+                lines.push('');
+            }
+            if (spec.info?.description) {
+                lines.push(spec.info.description);
+                lines.push('');
+            }
+            // List all endpoints with details
+            if (spec.paths) {
+                lines.push('### Endpoints');
+                lines.push('');
+                for (const [path, methods] of Object.entries(spec.paths)){
+                    for (const [method, details] of Object.entries(methods)){
+                        if (![
+                            'get',
+                            'post',
+                            'put',
+                            'patch',
+                            'delete'
+                        ].includes(method.toLowerCase())) continue;
+                        lines.push(`#### ${method.toUpperCase()} ${path}`);
+                        lines.push('');
+                        if (details.summary) {
+                            lines.push(`**${details.summary}**`);
+                            lines.push('');
+                        }
+                        if (details.description) {
+                            lines.push(details.description);
+                            lines.push('');
+                        }
+                        // Parameters
+                        if (details.parameters && details.parameters.length > 0) {
+                            lines.push('**Parameters:**');
+                            for (const param of details.parameters){
+                                const required = param.required ? ' (required)' : '';
+                                const desc = param.description ? `: ${param.description}` : '';
+                                lines.push(`- \`${param.name}\` (${param.in})${required}${desc}`);
+                            }
+                            lines.push('');
+                        }
+                        // Request body
+                        if (details.requestBody?.description) {
+                            lines.push(`**Request Body:** ${details.requestBody.description}`);
+                            lines.push('');
+                        }
+                        // Responses
+                        if (details.responses) {
+                            lines.push('**Responses:**');
+                            for (const [code, response] of Object.entries(details.responses)){
+                                lines.push(`- ${code}: ${response.description || 'No description'}`);
+                            }
+                            lines.push('');
+                        }
+                        lines.push('---');
+                        lines.push('');
+                    }
+                }
+            }
+        }
+    }
+}
+function generateChangelogContent(tab, lines) {
+    lines.push(`# ${tab.tab}`);
+    lines.push('');
+    const versions = getChangelogFiles();
+    for (const version of versions){
+        const pageData = getPageContent(`changelog/${version}`);
+        if (pageData) {
+            lines.push(`## ${pageData.title || `Version ${version}`}`);
+            lines.push('');
+            if (pageData.description) {
+                lines.push(`> ${pageData.description}`);
+                lines.push('');
+            }
+            if (pageData.content) {
+                lines.push(pageData.content);
+                lines.push('');
+            }
+            lines.push('---');
+            lines.push('');
+        }
+    }
+}
+function generateLlmsFullTxt(config) {
+    const lines = [];
+    // Header
+    const siteName = config.name || 'Documentation';
+    lines.push(`# ${siteName} - Full Documentation`);
+    lines.push('');
+    lines.push('> Complete documentation content for LLM consumption.');
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    // Process each tab from config
+    if (config.navigation?.tabs) {
+        for (const tab of config.navigation.tabs){
+            switch(tab.type){
+                case 'docs':
+                    generateDocsContent(tab, lines);
+                    break;
+                case 'openapi':
+                    generateOpenAPIContent(tab, lines);
+                    break;
+                case 'changelog':
+                    generateChangelogContent(tab, lines);
+                    break;
+            }
+        }
+    }
+    return lines.join('\n');
+}
+export async function GET() {
+    try {
+        // Check for custom llms-full.txt first
+        const customPath = join(DOCS_DIR, 'llms-full.txt');
+        if (existsSync(customPath)) {
+            const customContent = readFileSync(customPath, 'utf-8');
+            return new NextResponse(customContent, {
+                headers: {
+                    'Content-Type': 'text/plain; charset=utf-8',
+                    'Cache-Control': 'public, max-age=3600'
+                }
+            });
+        }
+        // Generate from docs.json config
+        const config = loadDocsConfig();
+        if (!config) {
+            return new NextResponse('# Documentation\n\nNo docs.json configuration found.', {
+                headers: {
+                    'Content-Type': 'text/plain; charset=utf-8'
+                }
+            });
+        }
+        const content = generateLlmsFullTxt(config);
+        return new NextResponse(content, {
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'public, max-age=3600'
+            }
+        });
+    } catch (error) {
+        console.error('Error generating llms-full.txt:', error);
+        return new NextResponse('Error generating llms-full.txt', {
+            status: 500
+        });
+    }
+}

package/renderer/app/llms.txt/route.js

@@ -0,0 +1,219 @@
+import { NextResponse } from 'next/server';
+import { join } from 'path';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import matter from 'gray-matter';
+/**
+ * llms.txt - Documentation index for LLMs
+ * 
+ * Generated from docs.json configuration.
+ * Helps LLMs understand and index your documentation structure.
+ */ const DOCS_DIR = join(process.cwd(), 'templates', 'starter');
+const BASE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'http://localhost:3000';
+function loadDocsConfig() {
+    const configPath = join(DOCS_DIR, 'docs.json');
+    if (!existsSync(configPath)) return null;
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return null;
+    }
+}
+function loadOpenAPISpec(specPath) {
+    const fullPath = join(DOCS_DIR, specPath);
+    if (!existsSync(fullPath)) return null;
+    try {
+        const content = readFileSync(fullPath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return null;
+    }
+}
+function getPageFrontmatter(slug) {
+    const extensions = [
+        '.mdx',
+        '.md'
+    ];
+    for (const ext of extensions){
+        const filePath = join(DOCS_DIR, `${slug}${ext}`);
+        if (existsSync(filePath)) {
+            try {
+                const content = readFileSync(filePath, 'utf-8');
+                const { data } = matter(content);
+                return {
+                    title: data.title,
+                    description: data.description
+                };
+            } catch  {
+                return {};
+            }
+        }
+    }
+    return {};
+}
+function getChangelogFiles() {
+    const changelogDir = join(DOCS_DIR, 'changelog');
+    if (!existsSync(changelogDir)) return [];
+    try {
+        return readdirSync(changelogDir).filter((f)=>(f.endsWith('.mdx') || f.endsWith('.md')) && f !== 'latest.mdx').map((f)=>{
+            const version = f.replace(/\.(mdx?|md)$/, '');
+            const frontmatter = getPageFrontmatter(`changelog/${version}`);
+            return {
+                version,
+                title: frontmatter.title,
+                description: frontmatter.description
+            };
+        }).sort((a, b)=>b.version.localeCompare(a.version));
+    } catch  {
+        return [];
+    }
+}
+function generateDocsSection(tab, lines) {
+    lines.push(`## ${tab.tab}`);
+    lines.push('');
+    if (tab.groups) {
+        for (const group of tab.groups){
+            lines.push(`### ${group.group}`);
+            lines.push('');
+            for (const page of group.pages){
+                const frontmatter = getPageFrontmatter(page);
+                const title = frontmatter.title || page.split('/').pop() || page;
+                const urlPath = page === 'index' ? '' : page;
+                const url = `${BASE_URL}/#${tab.tab.toLowerCase()}/page/${urlPath}`.replace(/\/+$/, '');
+                if (frontmatter.description) {
+                    lines.push(`- [${title}](${url}): ${frontmatter.description}`);
+                } else {
+                    lines.push(`- [${title}](${url})`);
+                }
+            }
+            lines.push('');
+        }
+    }
+}
+function generateOpenAPISection(tab, lines) {
+    lines.push(`## ${tab.tab}`);
+    lines.push('');
+    if (tab.versions && tab.versions.length > 0) {
+        for (const version of tab.versions){
+            const spec = loadOpenAPISpec(version.spec);
+            if (!spec) continue;
+            const versionLabel = version.default ? `${version.version} (current)` : version.version;
+            lines.push(`### ${versionLabel}`);
+            lines.push('');
+            if (spec.info?.description) {
+                lines.push(`> ${spec.info.description}`);
+                lines.push('');
+            }
+            // Group endpoints by tag or list all
+            if (spec.paths) {
+                const endpoints = [];
+                for (const [path, methods] of Object.entries(spec.paths)){
+                    for (const [method, details] of Object.entries(methods)){
+                        if ([
+                            'get',
+                            'post',
+                            'put',
+                            'patch',
+                            'delete'
+                        ].includes(method.toLowerCase())) {
+                            endpoints.push({
+                                method: method.toUpperCase(),
+                                path,
+                                summary: details.summary || details.description
+                            });
+                        }
+                    }
+                }
+                for (const endpoint of endpoints){
+                    if (endpoint.summary) {
+                        lines.push(`- **${endpoint.method}** \`${endpoint.path}\`: ${endpoint.summary}`);
+                    } else {
+                        lines.push(`- **${endpoint.method}** \`${endpoint.path}\``);
+                    }
+                }
+                lines.push('');
+            }
+        }
+    }
+}
+function generateChangelogSection(tab, lines) {
+    lines.push(`## ${tab.tab}`);
+    lines.push('');
+    const releases = getChangelogFiles();
+    if (releases.length > 0) {
+        for (const release of releases){
+            const title = release.title || `Version ${release.version}`;
+            const url = `${BASE_URL}/#changelog/page/changelog/${release.version}`;
+            if (release.description) {
+                lines.push(`- [${title}](${url}): ${release.description}`);
+            } else {
+                lines.push(`- [${title}](${url})`);
+            }
+        }
+    } else {
+        lines.push('- No releases found');
+    }
+    lines.push('');
+}
+function generateLlmsTxt(config) {
+    const lines = [];
+    // Header
+    const siteName = config.name || 'Documentation';
+    lines.push(`# ${siteName}`);
+    lines.push('');
+    lines.push('> Documentation index for LLMs. For full content, see /llms-full.txt');
+    lines.push('');
+    // Process each tab from config
+    if (config.navigation?.tabs) {
+        for (const tab of config.navigation.tabs){
+            switch(tab.type){
+                case 'docs':
+                    generateDocsSection(tab, lines);
+                    break;
+                case 'openapi':
+                    generateOpenAPISection(tab, lines);
+                    break;
+                case 'changelog':
+                    generateChangelogSection(tab, lines);
+                    break;
+            }
+        }
+    }
+    return lines.join('\n');
+}
+export async function GET() {
+    try {
+        // Check for custom llms.txt first
+        const customPath = join(DOCS_DIR, 'llms.txt');
+        if (existsSync(customPath)) {
+            const customContent = readFileSync(customPath, 'utf-8');
+            return new NextResponse(customContent, {
+                headers: {
+                    'Content-Type': 'text/plain; charset=utf-8',
+                    'Cache-Control': 'public, max-age=3600'
+                }
+            });
+        }
+        // Generate from docs.json config
+        const config = loadDocsConfig();
+        if (!config) {
+            return new NextResponse('# Documentation\n\nNo docs.json configuration found.', {
+                headers: {
+                    'Content-Type': 'text/plain; charset=utf-8'
+                }
+            });
+        }
+        const content = generateLlmsTxt(config);
+        return new NextResponse(content, {
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'public, max-age=3600'
+            }
+        });
+    } catch (error) {
+        console.error('Error generating llms.txt:', error);
+        return new NextResponse('Error generating llms.txt', {
+            status: 500
+        });
+    }
+}

package/renderer/app/page.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Docs } from "@/components/docs-viewer";
+import { MobileProvider } from "@/lib/api-docs/mobile-context";
+export default function Home() {
+    return /*#__PURE__*/ _jsx(MobileProvider, {
+        children: /*#__PURE__*/ _jsx("div", {
+            className: "min-h-screen bg-background",
+            children: /*#__PURE__*/ _jsx(Docs, {})
+        })
+    });
+}

package/renderer/app/robots.txt/route.js

@@ -0,0 +1,66 @@
+import { NextResponse } from 'next/server';
+import { join } from 'path';
+import { readFileSync, existsSync } from 'fs';
+/**
+ * robots.txt - Auto-generated robots file for search engines
+ */ const DOCS_DIR = join(process.cwd(), 'templates', 'starter');
+const BASE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'http://localhost:3000';
+function loadDocsConfig() {
+    const configPath = join(DOCS_DIR, 'docs.json');
+    if (!existsSync(configPath)) return null;
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    } catch  {
+        return null;
+    }
+}
+function generateRobotsTxt(config) {
+    const baseUrl = config.seo?.metatags?.canonical || BASE_URL;
+    const isNoIndex = config.seo?.metatags?.robots === 'noindex';
+    const lines = [];
+    lines.push('# robots.txt generated by Benjy');
+    lines.push('');
+    lines.push('User-agent: *');
+    if (isNoIndex) {
+        lines.push('Disallow: /');
+    } else {
+        lines.push('Allow: /');
+        lines.push('');
+        lines.push('# Disallow API routes');
+        lines.push('Disallow: /api/');
+    }
+    lines.push('');
+    lines.push(`Sitemap: ${baseUrl}/sitemap.xml`);
+    lines.push('');
+    return lines.join('\n');
+}
+export async function GET() {
+    try {
+        // Check for custom robots.txt first
+        const customPath = join(DOCS_DIR, 'robots.txt');
+        if (existsSync(customPath)) {
+            const customContent = readFileSync(customPath, 'utf-8');
+            return new NextResponse(customContent, {
+                headers: {
+                    'Content-Type': 'text/plain; charset=utf-8',
+                    'Cache-Control': 'public, max-age=3600'
+                }
+            });
+        }
+        // Generate default robots.txt
+        const config = loadDocsConfig();
+        const content = generateRobotsTxt(config || {});
+        return new NextResponse(content, {
+            headers: {
+                'Content-Type': 'text/plain; charset=utf-8',
+                'Cache-Control': 'public, max-age=3600'
+            }
+        });
+    } catch (error) {
+        console.error('Error generating robots.txt:', error);
+        return new NextResponse('Error generating robots.txt', {
+            status: 500
+        });
+    }
+}