@brainfish-ai/devdoc 0.1.41 → 0.1.43

package/renderer/app/api/proxy-stream/route.ts

@@ -1,168 +0,0 @@
-/**
- * Streaming Proxy Route
- * 
- * Forwards requests and streams responses back for SSE endpoints.
- * Auto-detects SSE based on response content-type.
- */
-
-import { NextRequest } from 'next/server'
-
-// Headers that should not be forwarded
-const EXCLUDED_REQUEST_HEADERS = [
-  'host',
-  'connection',
-  'content-length',
-  'transfer-encoding',
-  'keep-alive',
-  'upgrade',
-  'proxy-connection',
-  'proxy-authorization',
-]
-
-export async function POST(request: NextRequest) {
-  const startTime = Date.now()
-  
-  try {
-    const body = await request.json()
-    
-    const { url, method, headers, requestBody } = body as {
-      url: string
-      method: string
-      headers: Record<string, string>
-      requestBody?: string | null
-    }
-
-    if (!url) {
-      return new Response(
-        JSON.stringify({ error: 'URL is required' }),
-        { status: 400, headers: { 'Content-Type': 'application/json' } }
-      )
-    }
-
-    // Validate URL
-    const parsedUrl = new URL(url)
-    const allowedProtocols = ['http:', 'https:']
-    if (!allowedProtocols.includes(parsedUrl.protocol)) {
-      return new Response(
-        JSON.stringify({ error: 'Invalid URL protocol' }),
-        { status: 400, headers: { 'Content-Type': 'application/json' } }
-      )
-    }
-
-    // Build headers for the proxied request
-    const proxyHeaders: Record<string, string> = {}
-    for (const [key, value] of Object.entries(headers || {})) {
-      if (!EXCLUDED_REQUEST_HEADERS.includes(key.toLowerCase())) {
-        proxyHeaders[key] = value
-      }
-    }
-
-    // Make the proxied request
-    const response = await fetch(url, {
-      method: method || 'GET',
-      headers: proxyHeaders,
-      body: requestBody || undefined,
-    })
-
-    const contentType = response.headers.get('content-type') || ''
-    
-    // Check if this is a streaming response (SSE or similar)
-    const isStreaming = 
-      contentType.includes('text/event-stream') ||
-      contentType.includes('application/x-ndjson') ||
-      contentType.includes('application/stream+json')
-    
-    if (isStreaming && response.body) {
-      // For streaming responses, wrap in our SSE format
-      const encoder = new TextEncoder()
-      
-      // Send metadata first, then stream chunks
-      const stream = new ReadableStream({
-        async start(controller) {
-          // Send metadata
-          const metadata = {
-            type: 'metadata',
-            status: response.status,
-            statusText: response.statusText,
-            headers: Object.fromEntries(response.headers.entries()),
-            contentType,
-          }
-          controller.enqueue(encoder.encode(`data: ${JSON.stringify(metadata)}\n\n`))
-          
-          const reader = response.body!.getReader()
-          const decoder = new TextDecoder()
-          let totalSize = 0
-          
-          try {
-            while (true) {
-              const { done, value } = await reader.read()
-              
-              if (done) {
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', totalSize })}\n\n`))
-                controller.close()
-                break
-              }
-              
-              const chunk = decoder.decode(value, { stream: true })
-              totalSize += value.length
-              
-              // Send chunk
-              const chunkEvent = {
-                type: 'chunk',
-                data: chunk,
-                size: value.length,
-              }
-              controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunkEvent)}\n\n`))
-            }
-          } catch (error) {
-            const errorEvent = {
-              type: 'error',
-              error: error instanceof Error ? error.message : 'Stream error',
-            }
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(errorEvent)}\n\n`))
-            controller.close()
-          }
-        },
-      })
-
-      return new Response(stream, {
-        headers: {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          'Connection': 'keep-alive',
-        },
-      })
-    }
-
-    // For non-streaming responses, return as JSON
-    const responseBody = await response.text()
-    const responseHeaders: Record<string, string> = {}
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value
-    })
-
-    return new Response(
-      JSON.stringify({
-        status: response.status,
-        statusText: response.statusText,
-        headers: responseHeaders,
-        body: responseBody,
-        size: new Blob([responseBody]).size,
-        responseTime: Date.now() - startTime,
-        isStreaming: false,
-      }),
-      {
-        headers: { 'Content-Type': 'application/json' },
-      }
-    )
-  } catch (error) {
-    return new Response(
-      JSON.stringify({
-        status: 0,
-        statusText: 'Proxy Error',
-        error: error instanceof Error ? error.message : 'Proxy request failed',
-      }),
-      { status: 500, headers: { 'Content-Type': 'application/json' } }
-    )
-  }
-}

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

@@ -1,47 +0,0 @@
-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: string[]): string {
-  if (isAbsolute(STARTER_PATH)) {
-    return join(STARTER_PATH, ...paths)
-  }
-  return join(process.cwd(), STARTER_PATH, ...paths)
-}
-
-interface RedirectConfig {
-  source: string
-  destination: string
-}
-
-interface DocsConfig {
-  redirects?: RedirectConfig[]
-}
-
-/**
- * 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: 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.ts

@@ -1,73 +0,0 @@
-import { NextRequest, 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(): string {
-  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: NextRequest) {
-  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.ts

@@ -1,172 +0,0 @@
-import { NextRequest, 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',
-])
-
-interface CheckRequest {
-  subdomain: string
-}
-
-/**
- * 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: NextRequest) {
-  try {
-    const body = await request.json() as CheckRequest
-    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.ts

@@ -1,144 +0,0 @@
-import { generateObject } from 'ai'
-import { anthropic } from '@ai-sdk/anthropic'
-import { z } from 'zod'
-import type { EndpointIndex } from '@/lib/api-docs/agent/types'
-
-export const runtime = 'nodejs'
-
-// In-memory cache for suggestions (persists across requests in the same server instance)
-const suggestionsCache = new Map<string, { suggestions: Suggestion[]; timestamp: number }>()
-const CACHE_TTL = 1000 * 60 * 60 // 1 hour
-
-interface Suggestion {
-  title: string
-  label: string
-  prompt: string
-}
-
-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: EndpointIndex[], currentEndpointId?: string): string {
-  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
-  }, {} as Record<string, number>)
-
-  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: Request) {
-  try {
-    const body = await req.json()
-    const { endpointIndex, currentEndpointId } = body as {
-      endpointIndex: EndpointIndex[]
-      currentEndpointId?: string
-    }
-
-    // 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.tsx

@@ -1,54 +0,0 @@
-import type { Metadata, Viewport } from "next";
-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: Metadata = {
-  title: "Documentation",
-  description: "API Documentation and Reference",
-  icons: {
-    icon: '/icon.png',
-    shortcut: '/icon.png',
-    apple: '/icon.png',
-  },
-};
-
-export const viewport: Viewport = {
-  width: "device-width",
-  initialScale: 1,
-  maximumScale: 1,
-  userScalable: false,
-};
-
-export default function RootLayout({
-  children,
-}: Readonly<{
-  children: React.ReactNode;
-}>) {
-  return (
-    <html lang="en" suppressHydrationWarning>
-      <body
-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
-      >
-        <ThemeProvider
-          attribute="class"
-          defaultTheme="system"
-          enableSystem
-          disableTransitionOnChange
-        >
-          {children}
-        </ThemeProvider>
-      </body>
-    </html>
-  );
-}