@brainfish-ai/devdoc 0.1.41 → 0.1.43

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

@@ -1,1002 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readFileSync, existsSync, readdirSync } from 'fs'
-import { join, basename, isAbsolute } from 'path'
-import matter from 'gray-matter'
-import { CacheUtils } from '@/lib/cache'
-import { importOpenAPISpec } from '@/lib/api-docs/parsers/openapi'
-import { importGraphQLSchema, type BrainfishGraphQLCollection } from '@/lib/api-docs/parsers/graphql'
-import { generateAPISummary, formatAPISummaryForPrompt } from '@/lib/api-docs/agent/spec-summary'
-import { getProjectContent, type ProjectContent } from '@/lib/storage/blob'
-import type { OpenAPI } from 'openapi-types'
-import type { BrainfishCollection, BrainfishDocGroup, BrainfishDocPage } from '@/lib/api-docs/types'
-
-// Configuration
-const USE_LOCAL_SPEC = process.env.USE_LOCAL_SPEC !== 'false' // Default to true
-const STARTER_PATH = process.env.STARTER_PATH || 'devdoc-docs'
-const LOCAL_SPEC_PATH = process.env.LOCAL_SPEC_PATH || `${STARTER_PATH}/api-reference/openapi.json`
-
-// 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)
-}
-
-// Get the content root directory
-function getContentRoot(): string {
-  if (isAbsolute(STARTER_PATH)) {
-    return STARTER_PATH
-  }
-  return join(process.cwd(), STARTER_PATH)
-}
-const BRAINFISH_API_BASE_URL = process.env.BRAINFISH_API_BASE_URL || 'https://api.brainfish.ai/api'
-const BRAINFISH_CATALOG_ID = process.env.BRAINFISH_CATALOG_ID || 'your_catalog_id_here'
-const BRAINFISH_JWT_TOKEN = process.env.BRAINFISH_JWT_TOKEN || 'your_jwt_token_here'
-
-// Debug logging - only in verbose mode
-if (process.env.DEVDOC_VERBOSE === 'true') {
-  console.log('[Collections] Config:', {
-    useLocalSpec: USE_LOCAL_SPEC,
-    starterPath: STARTER_PATH,
-    localSpecPath: LOCAL_SPEC_PATH,
-  })
-}
-
-// Cache configuration
-const CACHE_KEY = USE_LOCAL_SPEC ? `collections-local` : `collections-${BRAINFISH_CATALOG_ID}`
-const CACHE_TTL = 60 * 5 // 5 minutes
-const FALLBACK_CACHE_KEY = `${CACHE_KEY}-fallback`
-const SUMMARY_CACHE_KEY = USE_LOCAL_SPEC ? `api-summary-local` : `api-summary-${BRAINFISH_CATALOG_ID}`
-const SUMMARY_CACHE_TTL = 60 * 60 * 24 // 1 day
-
-interface OpenApiSpec {
-  openapi: string
-  info: {
-    title: string
-    version: string
-    description: string
-  }
-  paths: Record<string, unknown>
-  servers?: Array<{
-    url: string
-    description: string
-  }>
-}
-
-// API version configuration
-interface ApiVersionConfig {
-  version: string
-  spec: string  // Path to the OpenAPI spec file
-  default?: boolean
-}
-
-// GraphQL schema configuration
-interface GraphQLSchemaConfig {
-  name?: string
-  schema: string  // Path to the GraphQL schema file (.graphql or .gql)
-  endpoint: string  // GraphQL endpoint URL
-  default?: boolean
-}
-
-// Nested group within pages array
-interface DocsConfigNestedGroup {
-  group: string
-  pages: string[]
-}
-
-// Page can be a string path or a nested group
-type DocsConfigPageItem = string | DocsConfigNestedGroup
-
-interface DocsConfigTab {
-  tab: string
-  type?: 'docs' | 'openapi' | 'changelog' | 'graphql'
-  path?: string  // URL path for the tab (e.g., "/api-reference", "/changelog")
-  versions?: ApiVersionConfig[]  // Multiple API versions (for openapi type)
-  // GraphQL-specific config
-  schema?: string  // Path to single GraphQL schema file
-  endpoint?: string  // GraphQL endpoint URL
-  schemas?: GraphQLSchemaConfig[]  // Multiple GraphQL schemas
-  groups?: Array<{
-    group: string
-    pages: DocsConfigPageItem[]
-    icon?: string  // Phosphor icon name for the group header
-  }>
-}
-
-interface DocsConfigLogo {
-  url?: string
-  alt?: string
-  width?: number
-  height?: number
-  light?: string
-  dark?: string
-}
-
-interface DocsConfigHeader {
-  showAskAI?: boolean
-  showSearch?: boolean
-  showThemeToggle?: boolean
-}
-
-interface DocsConfigNavbarLink {
-  label: string
-  href: string
-  external?: boolean
-}
-
-interface DocsConfigNavbarPrimary {
-  label: string
-  href: string
-}
-
-interface DocsConfigNavbar {
-  links?: DocsConfigNavbarLink[]
-  primary?: DocsConfigNavbarPrimary
-}
-
-interface DocsConfigNotice {
-  content: string
-  dismissible?: boolean
-  background?: string
-}
-
-interface DocsConfigRedirect {
-  source: string
-  destination: string
-}
-
-interface DocsConfig {
-  name?: string
-  favicon?: string
-  notice?: DocsConfigNotice
-  redirects?: DocsConfigRedirect[]
-  navigation?: {
-    tabs?: DocsConfigTab[]
-  }
-}
-
-// Theme configuration (from theme.json)
-interface ThemeConfig {
-  logo?: DocsConfigLogo
-  header?: DocsConfigHeader
-  navbar?: DocsConfigNavbar
-  colors?: {
-    primary?: string
-    primaryLight?: string
-    primaryDark?: string
-  }
-  typography?: {
-    fontFamily?: string
-    fontFamilyMono?: string
-    baseFontSize?: string
-  }
-  defaultTheme?: 'light' | 'dark' | 'system'
-  customCss?: string
-}
-
-// API version for the response
-interface ApiVersion {
-  version: string
-  spec: string
-  default: boolean
-}
-
-// GraphQL schema for the response
-interface GraphQLSchemaInfo {
-  name: string
-  schema: string
-  endpoint: string
-  default: boolean
-}
-
-// Navigation tab type for the response
-interface NavigationTab {
-  id: string
-  tab: string  // Tab name (used for both navigation and page header)
-  type: 'docs' | 'openapi' | 'changelog' | 'graphql'
-  path?: string
-  order: number
-  versions?: ApiVersion[]  // Available API versions (for openapi type)
-  graphqlSchemas?: GraphQLSchemaInfo[]  // Available GraphQL schemas (for graphql type)
-}
-
-// Changelog release type
-interface ChangelogRelease {
-  version: string
-  date: string
-  title: string
-  slug: string
-}
-
-// Load GraphQL schema from local file
-function loadGraphQLSchema(schemaPath: string): string | null {
-  try {
-    // Resolve the path similar to OpenAPI spec
-    const relativePath = schemaPath
-    const fullPath = relativePath.startsWith(STARTER_PATH) || isAbsolute(relativePath)
-      ? (isAbsolute(relativePath) ? relativePath : resolvePath(relativePath.replace(STARTER_PATH + '/', '')))
-      : resolvePath(relativePath)
-    
-    if (!existsSync(fullPath)) {
-      return null
-    }
-    
-    const content = readFileSync(fullPath, 'utf-8')
-    return content
-  } catch (error) {
-    console.error('[Collections] Error loading GraphQL schema:', error)
-    return null
-  }
-}
-
-// Load OpenAPI spec from local file
-function loadLocalSpec(specPath?: string): OpenApiSpec | null {
-  try {
-    // Use provided path or default
-    const relativePath = specPath || LOCAL_SPEC_PATH
-    // If the path already includes STARTER_PATH prefix, use it; otherwise prepend
-    const fullPath = relativePath.startsWith(STARTER_PATH) || isAbsolute(relativePath)
-      ? (isAbsolute(relativePath) ? relativePath : resolvePath(relativePath.replace(STARTER_PATH + '/', '')))
-      : resolvePath(relativePath)
-    
-    if (!existsSync(fullPath)) {
-      return null
-    }
-    
-    const content = readFileSync(fullPath, 'utf-8')
-    const spec = JSON.parse(content) as OpenApiSpec
-    
-    return spec
-  } catch (error) {
-    console.error('[Collections] Error loading local spec:', error)
-    return null
-  }
-}
-
-// Load docs.json configuration
-function loadDocsConfig(): DocsConfig | null {
-  try {
-    const configPath = resolvePath('docs.json')
-    
-    if (!existsSync(configPath)) {
-      return null
-    }
-    
-    const content = readFileSync(configPath, 'utf-8')
-    return JSON.parse(content) as DocsConfig
-  } catch (error) {
-    console.error('[Collections] Error loading docs.json:', error)
-    return null
-  }
-}
-
-// Load theme.json configuration
-function loadThemeConfig(): ThemeConfig | null {
-  try {
-    const configPath = resolvePath('theme.json')
-    
-    if (!existsSync(configPath)) {
-      return null
-    }
-    
-    const content = readFileSync(configPath, 'utf-8')
-    return JSON.parse(content) as ThemeConfig
-  } catch (error) {
-    console.error('[Collections] Error loading theme.json:', error)
-    return null
-  }
-}
-
-// Load custom CSS content
-function loadCustomCss(cssPath?: string): string | null {
-  if (!cssPath) return null
-
-  try {
-    const fullPath = resolvePath(cssPath)
-
-    if (!existsSync(fullPath)) {
-      return null
-    }
-
-    return readFileSync(fullPath, 'utf-8')
-  } catch (error) {
-    console.error('[Collections] Error loading custom CSS:', error)
-    return null
-  }
-}
-
-// Load MDX page metadata
-function loadPageMeta(pagePath: string): { title: string; description?: string; icon?: string } | null {
-  try {
-    const contentRoot = getContentRoot()
-    
-    // Try .mdx then .md
-    let fullPath = join(contentRoot, `${pagePath}.mdx`)
-    if (!existsSync(fullPath)) {
-      fullPath = join(contentRoot, `${pagePath}.md`)
-    }
-    if (!existsSync(fullPath)) {
-      return null
-    }
-    
-    const content = readFileSync(fullPath, 'utf-8')
-    const { data } = matter(content)
-    
-    return {
-      title: data.title || basename(pagePath),
-      description: data.description,
-      icon: data.icon,
-    }
-  } catch (error) {
-    console.error('[Collections] Error loading page meta:', pagePath, error)
-    return null
-  }
-}
-
-// Extract navigation tabs from docs.json in order
-function buildNavigationTabs(config: DocsConfig): NavigationTab[] {
-  const tabs: NavigationTab[] = []
-
-  if (!config.navigation?.tabs) {
-    return tabs
-  }
-
-  config.navigation.tabs.forEach((tab, index) => {
-    // Convert tab name to id (e.g., "API Reference" -> "api-reference")
-    const id = tab.tab.toLowerCase().replace(/\s+/g, '-')
-
-    // Determine the type (default to 'docs' if not specified)
-    const type = tab.type || 'docs'
-
-    // Build versions array for openapi tabs
-    let versions: ApiVersion[] | undefined
-    if (tab.type === 'openapi' && tab.versions && tab.versions.length > 0) {
-      versions = tab.versions.map(v => ({
-        version: v.version,
-        spec: v.spec,
-        default: v.default || false,
-      }))
-      // Ensure at least one default
-      if (!versions.some(v => v.default)) {
-        versions[0].default = true
-      }
-    }
-
-    // Build graphql schemas array for graphql tabs
-    let graphqlSchemas: GraphQLSchemaInfo[] | undefined
-    if (tab.type === 'graphql') {
-      if (tab.schemas && tab.schemas.length > 0) {
-        // Multiple schemas
-        graphqlSchemas = tab.schemas.map(s => ({
-          name: s.name || 'GraphQL API',
-          schema: s.schema,
-          endpoint: s.endpoint,
-          default: s.default || false,
-        }))
-        // Ensure at least one default
-        if (!graphqlSchemas.some(s => s.default)) {
-          graphqlSchemas[0].default = true
-        }
-      } else if (tab.schema && tab.endpoint) {
-        // Single schema
-        graphqlSchemas = [{
-          name: tab.tab,
-          schema: tab.schema,
-          endpoint: tab.endpoint,
-          default: true,
-        }]
-      }
-    }
-
-    tabs.push({
-      id,
-      tab: tab.tab,
-      type,
-      path: tab.path,
-      order: index,
-      versions,
-      graphqlSchemas,
-    })
-  })
-
-  return tabs
-}
-
-// Build documentation groups from docs.json
-function buildDocGroups(config: DocsConfig): BrainfishDocGroup[] {
-  const groups: BrainfishDocGroup[] = []
-  
-  if (!config.navigation?.tabs) {
-    return groups
-  }
-  
-  // Helper to process a page item (string or nested group)
-  const processPageItem = (
-    pageItem: DocsConfigPageItem, 
-    index: number, 
-    parentGroup: string
-  ): BrainfishDocPage | null => {
-    // Handle nested group
-    if (typeof pageItem === 'object' && 'group' in pageItem) {
-      const nestedGroup = pageItem as DocsConfigNestedGroup
-      const children: BrainfishDocPage[] = []
-      
-      for (let j = 0; j < nestedGroup.pages.length; j++) {
-        const childPath = nestedGroup.pages[j]
-        if (typeof childPath === 'string') {
-          const childMeta = loadPageMeta(childPath)
-          if (childMeta) {
-            children.push({
-              id: `doc-${childPath.replace(/\//g, '-')}`,
-              slug: childPath,
-              title: childMeta.title,
-              description: childMeta.description,
-              icon: childMeta.icon,
-              filePath: childPath,
-              group: nestedGroup.group,
-              order: j,
-            })
-          }
-        }
-      }
-      
-      if (children.length > 0) {
-        // Return a group item with children
-        return {
-          id: `group-${nestedGroup.group}`.toLowerCase().replace(/\s+/g, '-'),
-          slug: '', // Groups don't have a slug themselves
-          title: nestedGroup.group,
-          filePath: '',
-          group: parentGroup,
-          order: index,
-          isGroup: true,
-          children,
-        }
-      }
-      return null
-    }
-    
-    // Handle string page path
-    const pagePath = pageItem as string
-    const meta = loadPageMeta(pagePath)
-    
-    if (meta) {
-      return {
-        id: `doc-${pagePath.replace(/\//g, '-')}`,
-        slug: pagePath,
-        title: meta.title,
-        description: meta.description,
-        icon: meta.icon,
-        filePath: pagePath,
-        group: parentGroup,
-        order: index,
-      }
-    }
-    return null
-  }
-  
-  // Iterate through all tabs and their groups
-  for (const tab of config.navigation.tabs) {
-    // Skip tabs without groups (like API Reference with just href)
-    if (!tab.groups) {
-      continue
-    }
-    
-    for (const group of tab.groups) {
-      const pages: BrainfishDocPage[] = []
-      
-      for (let i = 0; i < group.pages.length; i++) {
-        const pageItem = group.pages[i]
-        const page = processPageItem(pageItem, i, group.group)
-        if (page) {
-          pages.push(page)
-        }
-      }
-      
-      if (pages.length > 0) {
-        groups.push({
-          id: `group-${tab.tab}-${group.group}`.toLowerCase().replace(/\s+/g, '-'),
-          title: group.group,
-          pages,
-          order: groups.length,
-          icon: group.icon,
-        })
-      }
-    }
-  }
-  
-  return groups
-}
-
-// Scan changelog directory for release files
-function scanChangelogReleases(): ChangelogRelease[] {
-  const releases: ChangelogRelease[] = []
-  const changelogDir = resolvePath('changelog')
-  
-  if (!existsSync(changelogDir)) {
-    return releases
-  }
-  
-  try {
-    const files = readdirSync(changelogDir)
-    
-    for (const file of files) {
-      // Only process versioned files (v1.0.0.mdx, etc.), skip latest.mdx and index files
-      if (!file.match(/^v[\d.]+\.mdx?$/)) {
-        continue
-      }
-      
-      const filePath = join(changelogDir, file)
-      const content = readFileSync(filePath, 'utf-8')
-      const { data } = matter(content)
-      
-      const version = data.version || file.replace(/\.mdx?$/, '')
-      
-      releases.push({
-        version,
-        date: data.date || '',
-        title: data.title || version,
-        slug: `changelog/${file.replace(/\.mdx?$/, '')}`,
-      })
-    }
-    
-    // Sort by version (newest first)
-    releases.sort((a, b) => {
-      const versionA = a.version.replace(/^v/, '').split('.').map(Number)
-      const versionB = b.version.replace(/^v/, '').split('.').map(Number)
-      
-      for (let i = 0; i < Math.max(versionA.length, versionB.length); i++) {
-        const numA = versionA[i] || 0
-        const numB = versionB[i] || 0
-        if (numA !== numB) return numB - numA
-      }
-      return 0
-    })
-    
-  } catch (error) {
-    console.error('[Collections] Error scanning changelog:', error)
-  }
-  
-  return releases
-}
-
-// Fetch OpenAPI spec from Brainfish API
-async function fetchRemoteSpec(): Promise<OpenApiSpec | null> {
-  const cachedSpec = await CacheUtils.get<OpenApiSpec>(CACHE_KEY)
-  if (cachedSpec) {
-    return cachedSpec
-  }
-
-  try {
-    const url = `${BRAINFISH_API_BASE_URL}/catalogs.openapi-spec`
-    
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${BRAINFISH_JWT_TOKEN}`,
-        'Accept': 'application/json',
-        'Content-Type': 'application/json',
-        'User-Agent': 'Brainfish-API-Docs/1.0',
-      },
-      body: JSON.stringify({ catalogId: BRAINFISH_CATALOG_ID }),
-      cache: 'no-store',
-    })
-
-    if (!response.ok) {
-      let errorBody = ''
-      try {
-        errorBody = await response.text()
-      } catch {
-        // ignore
-      }
-      throw new Error(`Failed to fetch: ${response.status} ${response.statusText}${errorBody ? ` - ${errorBody}` : ''}`)
-    }
-
-    const spec = await response.json() as OpenApiSpec
-    
-    await CacheUtils.set(CACHE_KEY, spec, CACHE_TTL)
-    await CacheUtils.set(FALLBACK_CACHE_KEY, spec, 60 * 60 * 24 * 365)
-    
-    return spec
-  } catch (error) {
-    console.error('[Collections] Error fetching remote spec:', error)
-    
-    const fallbackSpec = await CacheUtils.get<OpenApiSpec>(FALLBACK_CACHE_KEY)
-    if (fallbackSpec) {
-      return fallbackSpec
-    }
-    
-    return null
-  }
-}
-
-// Get OpenAPI spec (local or remote)
-async function getOpenApiSpec(specPath?: string): Promise<OpenApiSpec | null> {
-  if (USE_LOCAL_SPEC) {
-    const localSpec = loadLocalSpec(specPath)
-    if (localSpec) {
-      return localSpec
-    }
-  }
-  
-  return fetchRemoteSpec()
-}
-
-/**
- * Handle multi-tenant request - fetch content from Blob Storage
- */
-async function handleMultiTenantRequest(projectSlug: string, request: Request): Promise<Response> {
-  try {
-    const projectContent = await getProjectContent(projectSlug)
-    
-    if (!projectContent) {
-      return NextResponse.json(
-        { error: 'Project not found' },
-        { status: 404 }
-      )
-    }
-    
-    // Parse docs.json from project content
-    const docsConfig = JSON.parse(projectContent.docsJson) as DocsConfig
-    
-    // Build navigation tabs and doc groups from config
-    const navigationTabs = buildNavigationTabs(docsConfig)
-    const docGroups = buildDocGroupsFromBlob(docsConfig, projectContent)
-    
-    // For now, return docs-only response (no OpenAPI spec from blob)
-    return NextResponse.json(
-      {
-        id: projectSlug,
-        name: docsConfig.name || 'Documentation',
-        description: 'Documentation',
-        folders: [],
-        requests: [],
-        auth: { authType: 'none', authActive: true },
-        headers: [],
-        variables: [],
-        apiSummary: null,
-        docGroups,
-        navigationTabs,
-        changelogReleases: [],
-        docsName: docsConfig.name || null,
-        docsFavicon: docsConfig.favicon || null,
-        docsLogo: null,
-        docsHeader: null,
-        docsNavbar: null,
-        docsColors: null,
-        defaultTheme: null,
-        customCss: null,
-        apiVersions: [],
-        selectedApiVersion: null,
-        notice: docsConfig.notice || null,
-        isMultiTenant: true,
-        projectSlug,
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-          'Cache-Control': 'public, max-age=60',
-        },
-      }
-    )
-  } catch (error) {
-    console.error('[Collections] Multi-tenant error:', error)
-    return NextResponse.json(
-      { error: 'Failed to load project' },
-      { status: 500 }
-    )
-  }
-}
-
-/**
- * Build doc groups from Blob storage content
- */
-function buildDocGroupsFromBlob(config: DocsConfig, content: ProjectContent): BrainfishDocGroup[] {
-  const groups: BrainfishDocGroup[] = []
-  
-  if (!config.navigation?.tabs) {
-    return groups
-  }
-  
-  // Helper to find file content
-  const findFileContent = (pagePath: string): { title: string; description?: string; icon?: string } | null => {
-    const mdxPath = `${pagePath}.mdx`
-    const mdPath = `${pagePath}.md`
-    
-    const file = content.files.find(f => f.path === mdxPath || f.path === mdPath)
-    if (!file) return null
-    
-    try {
-      const { data } = matter(file.content)
-      return {
-        title: data.title || basename(pagePath),
-        description: data.description,
-        icon: data.icon,
-      }
-    } catch {
-      return { title: basename(pagePath) }
-    }
-  }
-  
-  // Process tabs and groups
-  for (const tab of config.navigation.tabs) {
-    if (!tab.groups) continue
-    
-    for (const group of tab.groups) {
-      const pages: BrainfishDocPage[] = []
-      
-      for (let i = 0; i < group.pages.length; i++) {
-        const pageItem = group.pages[i]
-        
-        if (typeof pageItem === 'string') {
-          const meta = findFileContent(pageItem)
-          if (meta) {
-            pages.push({
-              id: `doc-${pageItem.replace(/\//g, '-')}`,
-              slug: pageItem,
-              title: meta.title,
-              description: meta.description,
-              icon: meta.icon,
-              filePath: pageItem,
-              group: group.group,
-              order: i,
-            })
-          }
-        } else if ('group' in pageItem) {
-          // Nested group
-          const children: BrainfishDocPage[] = []
-          for (let j = 0; j < pageItem.pages.length; j++) {
-            const childPath = pageItem.pages[j]
-            if (typeof childPath === 'string') {
-              const childMeta = findFileContent(childPath)
-              if (childMeta) {
-                children.push({
-                  id: `doc-${childPath.replace(/\//g, '-')}`,
-                  slug: childPath,
-                  title: childMeta.title,
-                  description: childMeta.description,
-                  icon: childMeta.icon,
-                  filePath: childPath,
-                  group: pageItem.group,
-                  order: j,
-                })
-              }
-            }
-          }
-          
-          if (children.length > 0) {
-            pages.push({
-              id: `group-${pageItem.group}`.toLowerCase().replace(/\s+/g, '-'),
-              slug: '',
-              title: pageItem.group,
-              filePath: '',
-              group: group.group,
-              order: i,
-              isGroup: true,
-              children,
-            })
-          }
-        }
-      }
-      
-      if (pages.length > 0) {
-        groups.push({
-          id: `group-${tab.tab}-${group.group}`.toLowerCase().replace(/\s+/g, '-'),
-          title: group.group,
-          pages,
-          order: groups.length,
-          icon: group.icon,
-        })
-      }
-    }
-  }
-  
-  return groups
-}
-
-// Helper to generate or get cached summary
-async function getOrGenerateSummary(collection: BrainfishCollection, specVersion: string): Promise<string> {
-  const versionedCacheKey = `${SUMMARY_CACHE_KEY}-v${specVersion}`
-  
-  const cachedSummary = await CacheUtils.get<string>(versionedCacheKey)
-  if (cachedSummary) {
-    return cachedSummary
-  }
-  
-  const summary = generateAPISummary(collection)
-  const formattedSummary = formatAPISummaryForPrompt(summary)
-  
-  await CacheUtils.set(versionedCacheKey, formattedSummary, SUMMARY_CACHE_TTL)
-  
-  return formattedSummary
-}
-
-export async function GET(request: Request) {
-  try {
-    // Check for multi-tenant mode (project slug from middleware)
-    const projectSlug = request.headers.get('x-devdoc-project')
-    
-    // If multi-tenant, fetch from Blob Storage
-    if (projectSlug && !projectSlug.startsWith('custom:')) {
-      return handleMultiTenantRequest(projectSlug, request)
-    }
-    
-    // Parse query params
-    const { searchParams } = new URL(request.url)
-    const requestedVersion = searchParams.get('version')
-    
-    // Load docs and theme configuration
-    const docsConfig = loadDocsConfig()
-    const themeConfig = loadThemeConfig()
-    const customCss = loadCustomCss(themeConfig?.customCss)
-    const docGroups = docsConfig ? buildDocGroups(docsConfig) : []
-    const navigationTabs = docsConfig ? buildNavigationTabs(docsConfig) : []
-    const changelogReleases = scanChangelogReleases()
-    
-    // Find the OpenAPI tab and its versions
-    const openapiTab = navigationTabs.find(t => t.type === 'openapi')
-    const apiVersions = openapiTab?.versions || []
-    
-    // Determine which spec to load
-    let specPath: string | undefined
-    let selectedVersion: string | undefined
-    
-    if (apiVersions.length > 0) {
-      // Find requested version or default
-      const versionConfig = requestedVersion 
-        ? apiVersions.find(v => v.version === requestedVersion)
-        : apiVersions.find(v => v.default) || apiVersions[0]
-      
-      if (versionConfig) {
-        specPath = versionConfig.spec
-        selectedVersion = versionConfig.version
-      }
-    }
-    
-    // Get OpenAPI spec (with optional path for versioned specs)
-    const spec = await getOpenApiSpec(specPath)
-    
-    // Handle no spec available
-    if (!spec) {
-      return NextResponse.json(
-        {
-          id: 'empty',
-          name: docsConfig?.name || 'Documentation',
-          description: 'Welcome to the documentation.',
-          folders: [],
-          requests: [],
-          auth: { authType: 'none', authActive: true },
-          headers: [],
-          variables: [],
-          apiSummary: null,
-          docGroups,
-          navigationTabs,
-          changelogReleases,
-          docsName: docsConfig?.name || null,
-          docsFavicon: docsConfig?.favicon || null,
-          docsLogo: themeConfig?.logo || null,
-          docsHeader: themeConfig?.header || null,
-          docsNavbar: themeConfig?.navbar || null,
-          docsColors: themeConfig?.colors || null,
-          defaultTheme: themeConfig?.defaultTheme || null,
-          customCss: customCss || null,
-          apiVersions,
-          selectedApiVersion: selectedVersion,
-          notice: docsConfig?.notice || null,
-        },
-        {
-          headers: {
-            'Content-Type': 'application/json',
-            'Cache-Control': 'no-cache, no-store, must-revalidate',
-          },
-        }
-      )
-    }
-    
-    // Check if spec has paths
-    if (!spec.paths || Object.keys(spec.paths).length === 0) {
-      return NextResponse.json(
-        {
-          id: 'empty',
-          name: spec.info?.title || docsConfig?.name || 'Documentation',
-          description: spec.info?.description || 'No endpoints defined.',
-          folders: [],
-          requests: [],
-          auth: { authType: 'none', authActive: true },
-          headers: [],
-          variables: [],
-          apiSummary: null,
-          docGroups,
-          navigationTabs,
-          changelogReleases,
-          docsName: docsConfig?.name || null,
-          docsFavicon: docsConfig?.favicon || null,
-          docsLogo: themeConfig?.logo || null,
-          docsHeader: themeConfig?.header || null,
-          docsNavbar: themeConfig?.navbar || null,
-          docsColors: themeConfig?.colors || null,
-          defaultTheme: themeConfig?.defaultTheme || null,
-          customCss: customCss || null,
-          apiVersions,
-          selectedApiVersion: selectedVersion,
-          notice: docsConfig?.notice || null,
-        },
-        {
-          headers: {
-            'Content-Type': 'application/json',
-            'Cache-Control': 'no-cache, no-store, must-revalidate',
-          },
-        }
-      )
-    }
-    
-    // Convert to BrainfishCollection using our parser
-    const collections = await importOpenAPISpec(spec as OpenAPI.Document)
-    const collection = collections[0]
-    
-    if (!collection) {
-      return NextResponse.json(null, {
-        headers: {
-          'Content-Type': 'application/json',
-          'Cache-Control': 'no-cache, no-store, must-revalidate',
-        },
-      })
-    }
-    
-    // Generate or get cached API summary
-    const specVersion = spec.info?.version || 'unknown'
-    const apiSummary = await getOrGenerateSummary(collection, specVersion)
-    
-    // Return collection with summary and doc groups
-    return NextResponse.json(
-      {
-        ...collection,
-        apiSummary,
-        specVersion,
-        docGroups,
-        navigationTabs,
-        changelogReleases,
-        docsName: docsConfig?.name || null,
-        docsFavicon: docsConfig?.favicon || null,
-        docsLogo: themeConfig?.logo || null,
-        docsHeader: themeConfig?.header || null,
-        docsNavbar: themeConfig?.navbar || null,
-        docsColors: themeConfig?.colors || null,
-        defaultTheme: themeConfig?.defaultTheme || null,
-        customCss: customCss || null,
-        apiVersions,
-        selectedApiVersion: selectedVersion,
-        notice: docsConfig?.notice || null,
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-          'Cache-Control': 'no-cache, no-store, must-revalidate',
-        },
-      }
-    )
-  } catch (error) {
-    console.error('[Collections] Unexpected error:', error)
-    
-    return NextResponse.json(
-      {
-        id: 'error',
-        name: 'Documentation',
-        description: 'Failed to load documentation.',
-        folders: [],
-        requests: [],
-        auth: { authType: 'none', authActive: true },
-        headers: [],
-        variables: [],
-        docGroups: [],
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-          'Cache-Control': 'no-cache, no-store, must-revalidate',
-        },
-      }
-    )
-  }
-}