@brainfish-ai/devdoc 0.1.41 → 0.1.43

package/renderer/app/api/redirects/route.js

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+import { readFileSync, existsSync } from 'fs';
+import { join, isAbsolute } from 'path';
+// Configuration
+const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs';
+// Helper to resolve paths - supports both relative and absolute STARTER_PATH
+function resolvePath(...paths) {
+    if (isAbsolute(STARTER_PATH)) {
+        return join(STARTER_PATH, ...paths);
+    }
+    return join(process.cwd(), STARTER_PATH, ...paths);
+}
+/**
+ * GET /api/redirects
+ * Returns the redirect configuration from docs.json
+ */ export async function GET() {
+    try {
+        const docsJsonPath = resolvePath('docs.json');
+        if (!existsSync(docsJsonPath)) {
+            return NextResponse.json({
+                redirects: []
+            });
+        }
+        const docsJsonContent = readFileSync(docsJsonPath, 'utf-8');
+        const docsConfig = JSON.parse(docsJsonContent);
+        return NextResponse.json({
+            redirects: docsConfig.redirects || []
+        });
+    } catch (error) {
+        console.error('[Redirects API] Error:', error);
+        return NextResponse.json({
+            redirects: []
+        });
+    }
+}

package/renderer/app/api/schema/route.js

@@ -0,0 +1,85 @@
+import { NextResponse } from 'next/server';
+import { readFileSync, existsSync } from 'fs';
+import { join, isAbsolute } from 'path';
+import { getProjectContent } from '@/lib/storage/blob';
+// Configuration - match collections route
+const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs';
+// Get the docs directory - respects STARTER_PATH for local development
+function getDocsDir() {
+    const projectSlug = process.env.BRAINFISH_PROJECT_SLUG;
+    if (projectSlug) {
+        return join(process.cwd(), '.devdoc', projectSlug);
+    }
+    // Use STARTER_PATH (can be absolute or relative)
+    if (isAbsolute(STARTER_PATH)) {
+        return STARTER_PATH;
+    }
+    return join(process.cwd(), STARTER_PATH);
+}
+export async function GET(request) {
+    const searchParams = request.nextUrl.searchParams;
+    const path = searchParams.get('path');
+    if (!path) {
+        return NextResponse.json({
+            error: 'Missing path parameter'
+        }, {
+            status: 400
+        });
+    }
+    // Security: Only allow .graphql, .gql files
+    if (!path.endsWith('.graphql') && !path.endsWith('.gql')) {
+        return NextResponse.json({
+            error: 'Invalid file type'
+        }, {
+            status: 400
+        });
+    }
+    // Security: Prevent path traversal
+    if (path.includes('..')) {
+        return NextResponse.json({
+            error: 'Invalid path'
+        }, {
+            status: 400
+        });
+    }
+    try {
+        // Try blob storage first (for deployed projects)
+        const projectSlug = process.env.BRAINFISH_PROJECT_SLUG;
+        if (projectSlug) {
+            const projectContent = await getProjectContent(projectSlug);
+            if (projectContent?.files) {
+                const file = projectContent.files.find((f)=>f.path === path || f.path === `/${path}`);
+                if (file?.content) {
+                    return new NextResponse(file.content, {
+                        headers: {
+                            'Content-Type': 'text/plain'
+                        }
+                    });
+                }
+            }
+        }
+        // Try local filesystem
+        const docsDir = getDocsDir();
+        const fullPath = join(docsDir, path);
+        if (!existsSync(fullPath)) {
+            return NextResponse.json({
+                error: 'Schema file not found'
+            }, {
+                status: 404
+            });
+        }
+        const content = readFileSync(fullPath, 'utf-8');
+        return new NextResponse(content, {
+            headers: {
+                'Content-Type': 'text/plain'
+            }
+        });
+    } catch (error) {
+        console.error('[Schema API] Error:', error);
+        return NextResponse.json({
+            error: 'Failed to read schema'
+        }, {
+            status: 500
+        });
+    }
+}

package/renderer/app/api/subdomains/check/route.js

@@ -0,0 +1,158 @@
+import { NextResponse } from 'next/server';
+import { isSubdomainRegistered } from '@/lib/storage/blob';
+// Reserved/blacklisted subdomains
+const BLACKLISTED_SUBDOMAINS = new Set([
+    // Generic reserved
+    'www',
+    'api',
+    'app',
+    'admin',
+    'dashboard',
+    'console',
+    'panel',
+    'manage',
+    'login',
+    'signin',
+    'signup',
+    'register',
+    'auth',
+    'oauth',
+    'sso',
+    // Brand/product
+    'devdoc',
+    'brainfish',
+    'docs',
+    'documentation',
+    'help',
+    'support',
+    'status',
+    'blog',
+    'news',
+    // Infrastructure
+    'mail',
+    'email',
+    'smtp',
+    'ftp',
+    'cdn',
+    'static',
+    'assets',
+    'images',
+    'files',
+    'media',
+    'download',
+    'downloads',
+    // Common
+    'test',
+    'testing',
+    'dev',
+    'development',
+    'staging',
+    'prod',
+    'production',
+    'demo',
+    'example',
+    'sandbox',
+    'preview',
+    // Security
+    'secure',
+    'ssl',
+    'security',
+    'abuse',
+    'spam',
+    'postmaster',
+    'hostmaster',
+    'webmaster',
+    // Misc
+    'null',
+    'undefined',
+    'true',
+    'false',
+    'root',
+    'system',
+    'localhost'
+]);
+/**
+ * POST /api/subdomains/check
+ * Check if a subdomain is available
+ * 
+ * Body:
+ *   subdomain: string - The subdomain to check
+ * 
+ * Returns:
+ *   available: boolean
+ *   error?: string - If not available, why
+ *   suggestion?: string - Alternative suggestion
+ */ export async function POST(request) {
+    try {
+        const body = await request.json();
+        const { subdomain } = body;
+        if (!subdomain) {
+            return NextResponse.json({
+                available: false,
+                error: 'Subdomain is required'
+            }, {
+                status: 400
+            });
+        }
+        // Normalize subdomain
+        const normalized = subdomain.toLowerCase().trim();
+        // Format validation
+        if (normalized.length < 3) {
+            return NextResponse.json({
+                available: false,
+                error: 'Subdomain must be at least 3 characters'
+            });
+        }
+        if (normalized.length > 63) {
+            return NextResponse.json({
+                available: false,
+                error: 'Subdomain must be 63 characters or less'
+            });
+        }
+        if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(normalized)) {
+            return NextResponse.json({
+                available: false,
+                error: 'Subdomain must start and end with alphanumeric characters, and can only contain lowercase letters, numbers, and hyphens'
+            });
+        }
+        if (/--/.test(normalized)) {
+            return NextResponse.json({
+                available: false,
+                error: 'Subdomain cannot contain consecutive hyphens'
+            });
+        }
+        // Check blacklist
+        if (BLACKLISTED_SUBDOMAINS.has(normalized)) {
+            // Generate suggestion
+            const suggestion = `${normalized}-docs`;
+            return NextResponse.json({
+                available: false,
+                error: `"${normalized}" is a reserved subdomain`,
+                suggestion
+            });
+        }
+        // Check if subdomain is already registered (O(1) lookup from registry)
+        const exists = await isSubdomainRegistered(normalized);
+        if (exists) {
+            // Generate suggestion with random suffix
+            const suffix = Math.random().toString(36).substring(2, 6);
+            const suggestion = `${normalized}-${suffix}`;
+            return NextResponse.json({
+                available: false,
+                error: `"${normalized}" is already taken`,
+                suggestion
+            });
+        }
+        return NextResponse.json({
+            available: true
+        });
+    } catch (error) {
+        console.error('[Subdomains API] Check Error:', error);
+        return NextResponse.json({
+            available: false,
+            error: 'Internal server error'
+        }, {
+            status: 500
+        });
+    }
+}

package/renderer/app/api/suggestions/route.js

@@ -0,0 +1,175 @@
+import { generateObject } from 'ai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { z } from 'zod';
+export const runtime = 'nodejs';
+// In-memory cache for suggestions (persists across requests in the same server instance)
+const suggestionsCache = new Map();
+const CACHE_TTL = 1000 * 60 * 60 // 1 hour
+;
+const SuggestionsSchema = z.object({
+    suggestions: z.array(z.object({
+        title: z.string().describe('Short action phrase (2-4 words) like "Find endpoints" or "How do I"'),
+        label: z.string().describe('Completion of the title (2-5 words) like "for user management" or "authenticate?"'),
+        prompt: z.string().describe('Full question the user would ask')
+    })).length(4)
+});
+function buildSuggestionPrompt(endpoints, currentEndpointId) {
+    const currentEndpoint = currentEndpointId ? endpoints.find((e)=>e.id === currentEndpointId) : null;
+    if (currentEndpoint) {
+        return `You are helping users explore an API. Generate 4 helpful question suggestions for the "${currentEndpoint.name}" endpoint.
+
+Endpoint details:
+- Name: ${currentEndpoint.name}
+- Method: ${currentEndpoint.method}
+- Path: ${currentEndpoint.path}
+- Description: ${currentEndpoint.description || 'No description'}
+- Parameters: ${currentEndpoint.parameters.join(', ') || 'None'}
+- Has request body: ${currentEndpoint.hasBody}
+
+Generate questions that help users:
+1. Understand what this endpoint does
+2. Know what parameters/data to send
+3. See example requests or responses
+4. Understand error handling or edge cases
+
+Make questions specific to this endpoint, not generic.`;
+    }
+    // General suggestions based on the API
+    const methodCounts = endpoints.reduce((acc, e)=>{
+        acc[e.method] = (acc[e.method] || 0) + 1;
+        return acc;
+    }, {});
+    const categories = [
+        ...new Set(endpoints.flatMap((e)=>e.tags))
+    ].slice(0, 5);
+    return `You are helping users explore an API documentation. Generate 4 helpful starter question suggestions.
+
+API Overview:
+- Total endpoints: ${endpoints.length}
+- Methods: ${Object.entries(methodCounts).map(([m, c])=>`${m}: ${c}`).join(', ')}
+- Categories: ${categories.join(', ') || 'General'}
+
+Sample endpoints:
+${endpoints.slice(0, 8).map((e)=>`- ${e.method} ${e.name}: ${e.description || 'No description'}`).join('\n')}
+
+Generate questions that help users:
+1. Find the right endpoint for their use case
+2. Understand authentication/authorization
+3. Explore common operations (create, read, update, delete)
+4. Get started quickly with the API
+
+Make questions specific to this API's capabilities.`;
+}
+export async function POST(req) {
+    try {
+        const body = await req.json();
+        const { endpointIndex, currentEndpointId } = body;
+        // Create cache key based on endpoint context
+        const cacheKey = currentEndpointId ? `endpoint:${currentEndpointId}` : `general:${endpointIndex.length}`;
+        // Check cache
+        const cached = suggestionsCache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+            return Response.json({
+                suggestions: cached.suggestions,
+                cached: true
+            });
+        }
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            // Return fallback suggestions if no API key
+            const fallback = currentEndpointId ? [
+                {
+                    title: 'What does this',
+                    label: 'endpoint do?',
+                    prompt: 'What does this endpoint do?'
+                },
+                {
+                    title: 'What parameters',
+                    label: 'are required?',
+                    prompt: 'What parameters are required?'
+                },
+                {
+                    title: 'Show me an',
+                    label: 'example request',
+                    prompt: 'Show me an example request'
+                },
+                {
+                    title: 'What are the',
+                    label: 'possible responses?',
+                    prompt: 'What are the possible responses?'
+                }
+            ] : [
+                {
+                    title: 'Find endpoints',
+                    label: 'for creating resources',
+                    prompt: 'Find endpoints for creating resources'
+                },
+                {
+                    title: 'How do I',
+                    label: 'authenticate?',
+                    prompt: 'How do I authenticate?'
+                },
+                {
+                    title: 'What APIs are',
+                    label: 'available?',
+                    prompt: 'What APIs are available?'
+                },
+                {
+                    title: 'Show me',
+                    label: 'GET endpoints',
+                    prompt: 'Show me all GET endpoints'
+                }
+            ];
+            return Response.json({
+                suggestions: fallback,
+                cached: false,
+                fallback: true
+            });
+        }
+        const prompt = buildSuggestionPrompt(endpointIndex, currentEndpointId);
+        const { object } = await generateObject({
+            model: anthropic('claude-sonnet-4-20250514'),
+            schema: SuggestionsSchema,
+            prompt
+        });
+        // Cache the result
+        suggestionsCache.set(cacheKey, {
+            suggestions: object.suggestions,
+            timestamp: Date.now()
+        });
+        return Response.json({
+            suggestions: object.suggestions,
+            cached: false
+        });
+    } catch (error) {
+        console.error('[Suggestions API] Error:', error);
+        // Return fallback on error
+        const fallback = [
+            {
+                title: 'What APIs are',
+                label: 'available?',
+                prompt: 'What APIs are available?'
+            },
+            {
+                title: 'How do I',
+                label: 'authenticate?',
+                prompt: 'How do I authenticate?'
+            },
+            {
+                title: 'Find endpoints',
+                label: 'for my use case',
+                prompt: 'Help me find the right endpoint'
+            },
+            {
+                title: 'Show me',
+                label: 'examples',
+                prompt: 'Show me some example requests'
+            }
+        ];
+        return Response.json({
+            suggestions: fallback,
+            cached: false,
+            error: true
+        });
+    }
+}

package/renderer/app/layout.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Geist, Geist_Mono } from "next/font/google";
+import { ThemeProvider } from "@/components/theme-provider";
+import "./globals.css";
+const geistSans = Geist({
+    variable: "--font-geist-sans",
+    subsets: [
+        "latin"
+    ]
+});
+const geistMono = Geist_Mono({
+    variable: "--font-geist-mono",
+    subsets: [
+        "latin"
+    ]
+});
+export const metadata = {
+    title: "Documentation",
+    description: "API Documentation and Reference",
+    icons: {
+        icon: '/icon.png',
+        shortcut: '/icon.png',
+        apple: '/icon.png'
+    }
+};
+export const viewport = {
+    width: "device-width",
+    initialScale: 1,
+    maximumScale: 1,
+    userScalable: false
+};
+export default function RootLayout({ children }) {
+    return /*#__PURE__*/ _jsx("html", {
+        lang: "en",
+        suppressHydrationWarning: true,
+        children: /*#__PURE__*/ _jsx("body", {
+            className: `${geistSans.variable} ${geistMono.variable} antialiased`,
+            children: /*#__PURE__*/ _jsx(ThemeProvider, {
+                attribute: "class",
+                defaultTheme: "system",
+                enableSystem: true,
+                disableTransitionOnChange: true,
+                children: children
+            })
+        })
+    });
+}