@raystack/chronicle 0.1.0-canary.5a730d4 → 0.1.0-canary.67113f8

package/src/lib/config.ts

@@ -1,56 +1,58 @@
-import fs from 'fs'
-import path from 'path'
-import { parse } from 'yaml'
-import type { ChronicleConfig } from '@/types'
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse } from 'yaml';
+import type { ChronicleConfig } from '@/types';
 
-const CONFIG_FILE = 'chronicle.yaml'
+const CONFIG_FILE = 'chronicle.yaml';
 
 const defaultConfig: ChronicleConfig = {
   title: 'Documentation',
   theme: { name: 'default' },
-  search: { enabled: true, placeholder: 'Search...' },
-}
+  search: { enabled: true, placeholder: 'Search...' }
+};
 
 function resolveConfigPath(): string | null {
-  // Check project root via env var
-  const projectRoot = process.env.CHRONICLE_PROJECT_ROOT
-  if (projectRoot) {
-    const rootPath = path.join(projectRoot, CONFIG_FILE)
-    if (fs.existsSync(rootPath)) return rootPath
-  }
-  // Check cwd
-  const cwdPath = path.join(process.cwd(), CONFIG_FILE)
-  if (fs.existsSync(cwdPath)) return cwdPath
-  // Check content dir
-  const contentDir = process.env.CHRONICLE_CONTENT_DIR
+  const projectRoot =
+    typeof __CHRONICLE_PROJECT_ROOT__ !== 'undefined'
+      ? __CHRONICLE_PROJECT_ROOT__
+      : process.cwd();
+
+  const rootPath = path.join(projectRoot, CONFIG_FILE);
+  if (fs.existsSync(rootPath)) return rootPath;
+
+  const contentDir =
+    typeof __CHRONICLE_CONTENT_DIR__ !== 'undefined'
+      ? __CHRONICLE_CONTENT_DIR__
+      : undefined;
   if (contentDir) {
-    const contentPath = path.join(contentDir, CONFIG_FILE)
-    if (fs.existsSync(contentPath)) return contentPath
+    const contentPath = path.join(contentDir, CONFIG_FILE);
+    if (fs.existsSync(contentPath)) return contentPath;
   }
-  return null
+
+  return null;
 }
 
 export function loadConfig(): ChronicleConfig {
-  const configPath = resolveConfigPath()
+  const configPath = resolveConfigPath();
 
   if (!configPath) {
-    return defaultConfig
+    return defaultConfig;
   }
 
-  const raw = fs.readFileSync(configPath, 'utf-8')
-  const userConfig = parse(raw) as Partial<ChronicleConfig>
+  const raw = fs.readFileSync(configPath, 'utf-8');
+  const userConfig = parse(raw) as Partial<ChronicleConfig>;
 
   return {
     ...defaultConfig,
     ...userConfig,
     theme: {
       name: userConfig.theme?.name ?? defaultConfig.theme!.name,
-      colors: { ...defaultConfig.theme?.colors, ...userConfig.theme?.colors },
+      colors: { ...defaultConfig.theme?.colors, ...userConfig.theme?.colors }
     },
     search: { ...defaultConfig.search, ...userConfig.search },
     footer: userConfig.footer,
     api: userConfig.api,
     llms: { enabled: false, ...userConfig.llms },
-    analytics: { enabled: false, ...userConfig.analytics },
-  }
-}
+    analytics: { enabled: false, ...userConfig.analytics }
+  };
+}

package/src/lib/get-llm-text.ts

@@ -0,0 +1,10 @@
+import { source } from '@/lib/source'
+import type { InferPageType } from 'fumadocs-core/source'
+
+export async function getLLMText(page: InferPageType<typeof source>) {
+  const processed = await page.data.getText('processed')
+
+  return `# ${page.data.title} (${page.url})
+
+${processed}`
+}

package/src/lib/head.tsx

@@ -1,45 +1,49 @@
-import type { ChronicleConfig } from '@/types'
+import type { ChronicleConfig } from '@/types';
 
 export interface HeadProps {
-  title: string
-  description?: string
-  config: ChronicleConfig
-  jsonLd?: Record<string, unknown>
+  title: string;
+  description?: string;
+  config: ChronicleConfig;
+  jsonLd?: Record<string, unknown>;
 }
 
 export function Head({ title, description, config, jsonLd }: HeadProps) {
-  const fullTitle = `${title} | ${config.title}`
-  const ogParams = new URLSearchParams({ title })
-  if (description) ogParams.set('description', description)
+  const fullTitle = `${title} | ${config.title}`;
+  const ogParams = new URLSearchParams({ title });
+  if (description) ogParams.set('description', description);
 
   return (
     <>
       <title>{fullTitle}</title>
-      {description && <meta name="description" content={description} />}
+      {description && <meta name='description' content={description} />}
 
       {config.url && (
         <>
-          <meta property="og:title" content={title} />
-          {description && <meta property="og:description" content={description} />}
-          <meta property="og:site_name" content={config.title} />
-          <meta property="og:type" content="website" />
-          <meta property="og:image" content={`/og?${ogParams.toString()}`} />
-          <meta property="og:image:width" content="1200" />
-          <meta property="og:image:height" content="630" />
+          <meta property='og:title' content={title} />
+          {description && (
+            <meta property='og:description' content={description} />
+          )}
+          <meta property='og:site_name' content={config.title} />
+          <meta property='og:type' content='website' />
+          <meta property='og:image' content={`/og?${ogParams.toString()}`} />
+          <meta property='og:image:width' content='1200' />
+          <meta property='og:image:height' content='630' />
 
-          <meta name="twitter:card" content="summary_large_image" />
-          <meta name="twitter:title" content={title} />
-          {description && <meta name="twitter:description" content={description} />}
-          <meta name="twitter:image" content={`/og?${ogParams.toString()}`} />
+          <meta name='twitter:card' content='summary_large_image' />
+          <meta name='twitter:title' content={title} />
+          {description && (
+            <meta name='twitter:description' content={description} />
+          )}
+          <meta name='twitter:image' content={`/og?${ogParams.toString()}`} />
         </>
       )}
 
       {jsonLd && (
         <script
-          type="application/ld+json"
+          type='application/ld+json'
           dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd, null, 2) }}
         />
       )}
     </>
-  )
+  );
 }

package/src/lib/mdx-loader.ts

@@ -0,0 +1,21 @@
+import React, { type ReactNode } from 'react';
+import type { TableOfContents } from 'fumadocs-core/toc';
+import { mdxComponents } from '@/components/mdx';
+
+const contentModules = import.meta.glob<{ default?: React.ComponentType<any>; toc?: TableOfContents }>(
+  '../../.content/**/*.{mdx,md}'
+);
+
+export async function loadMdxModule(relativePath: string): Promise<{ content: ReactNode; toc: TableOfContents }> {
+  const withoutExt = relativePath.replace(/\.(mdx|md)$/, '');
+  const key = relativePath.endsWith('.md')
+    ? `../../.content/${withoutExt}.md`
+    : `../../.content/${withoutExt}.mdx`;
+  const loader = contentModules[key];
+  if (!loader) return { content: null, toc: [] };
+  const mod = await loader();
+  const content = mod.default
+    ? React.createElement(mod.default, { components: mdxComponents })
+    : null;
+  return { content, toc: mod.toc ?? [] };
+}

package/src/lib/openapi.ts

@@ -1,5 +1,5 @@
-import fs from 'fs'
-import path from 'path'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import { parse as parseYaml } from 'yaml'
 import type { OpenAPIV2, OpenAPIV3 } from 'openapi-types'
 import type { ApiConfig, ApiServerConfig, ApiAuthConfig } from '@/types/config'
@@ -17,14 +17,14 @@ export interface ApiSpec {
 export type { SchemaField } from './schema'
 export { flattenSchema } from './schema'
 
-export function loadApiSpecs(apiConfigs: ApiConfig[]): ApiSpec[] {
-  const contentDir = process.env.CHRONICLE_CONTENT_DIR ?? process.cwd()
-  return apiConfigs.map((config) => loadApiSpec(config, contentDir))
+export async function loadApiSpecs(apiConfigs: ApiConfig[]): Promise<ApiSpec[]> {
+  const projectRoot = typeof __CHRONICLE_PROJECT_ROOT__ !== 'undefined' ? __CHRONICLE_PROJECT_ROOT__ : process.cwd()
+  return Promise.all(apiConfigs.map((config) => loadApiSpec(config, projectRoot)))
 }
 
-export function loadApiSpec(config: ApiConfig, contentDir: string): ApiSpec {
-  const specPath = path.resolve(contentDir, config.spec)
-  const raw = fs.readFileSync(specPath, 'utf-8')
+export async function loadApiSpec(config: ApiConfig, projectRoot: string): Promise<ApiSpec> {
+  const specPath = path.resolve(projectRoot, config.spec)
+  const raw = await fs.readFile(specPath, 'utf-8')
   const isYaml = specPath.endsWith('.yaml') || specPath.endsWith('.yml')
   const doc = (isYaml ? parseYaml(raw) : JSON.parse(raw)) as OpenAPIV2.Document | OpenAPIV3.Document
 

package/src/lib/page-context.tsx

@@ -1,95 +1,111 @@
-import { createContext, useContext, useState, useEffect, type ReactNode } from 'react'
-import { useLocation } from 'react-router-dom'
-import type { ChronicleConfig, Frontmatter, PageTree } from '@/types'
-import type { ApiSpec } from '@/lib/openapi'
-import { getPage, loadPageComponent, buildPageTree } from '@/lib/source'
-import { mdxComponents } from '@/components/mdx'
-import React from 'react'
+import {
+  createContext,
+  type ReactNode,
+  useContext,
+  useEffect,
+  useState
+} from 'react';
+import { useLocation } from 'react-router';
+import type { ApiSpec } from '@/lib/openapi';
+import type { ChronicleConfig, Frontmatter, Root, TableOfContents } from '@/types';
+
+export type MdxLoader = (relativePath: string) => Promise<{ content: ReactNode; toc: TableOfContents }>;
 
 interface PageData {
-  slug: string[]
-  frontmatter: Frontmatter
-  content: ReactNode
+  slug: string[];
+  frontmatter: Frontmatter;
+  content: ReactNode;
+  toc: TableOfContents;
 }
 
 interface PageContextValue {
-  config: ChronicleConfig
-  tree: PageTree
-  page: PageData | null
-  apiSpecs: ApiSpec[]
+  config: ChronicleConfig;
+  tree: Root;
+  page: PageData | null;
+  apiSpecs: ApiSpec[];
 }
 
-const PageContext = createContext<PageContextValue | null>(null)
+const PageContext = createContext<PageContextValue | null>(null);
 
 export function usePageContext(): PageContextValue {
-  const ctx = useContext(PageContext)
+  const ctx = useContext(PageContext);
   if (!ctx) {
-    console.error('usePageContext: no context found!')
+    console.error('usePageContext: no context found!');
     return {
       config: { title: 'Documentation' },
-      tree: { name: 'root', children: [] },
+      tree: { name: 'root', children: [] } as Root,
       page: null,
-      apiSpecs: [],
-    }
+      apiSpecs: []
+    };
   }
-  return ctx
+  return ctx;
 }
 
 interface PageProviderProps {
-  initialConfig: ChronicleConfig
-  initialTree: PageTree
-  initialPage: PageData | null
-  initialApiSpecs: ApiSpec[]
-  children: ReactNode
+  initialConfig: ChronicleConfig;
+  initialTree: Root;
+  initialPage: PageData | null;
+  initialApiSpecs: ApiSpec[];
+  loadMdx: MdxLoader;
+  children: ReactNode;
 }
 
-export function PageProvider({ initialConfig, initialTree, initialPage, initialApiSpecs, children }: PageProviderProps) {
-  const { pathname } = useLocation()
-  const [tree, setTree] = useState<PageTree>(initialTree)
-  const [page, setPage] = useState<PageData | null>(initialPage)
-  const [apiSpecs, setApiSpecs] = useState<ApiSpec[]>(initialApiSpecs)
-  const [currentPath, setCurrentPath] = useState(pathname)
+export function PageProvider({
+  initialConfig,
+  initialTree,
+  initialPage,
+  initialApiSpecs,
+  loadMdx,
+  children
+}: PageProviderProps) {
+  const { pathname } = useLocation();
+  const [tree] = useState<Root>(initialTree);
+  const [page, setPage] = useState<PageData | null>(initialPage);
+  const [apiSpecs, setApiSpecs] = useState<ApiSpec[]>(initialApiSpecs);
+  const [currentPath, setCurrentPath] = useState(pathname);
 
   useEffect(() => {
-    if (pathname === currentPath) return
-    setCurrentPath(pathname)
+    if (pathname === currentPath) return;
+    setCurrentPath(pathname);
 
-    let cancelled = false
+    const cancelled = { current: false };
 
     if (pathname.startsWith('/apis')) {
-      // Fetch API specs if not already loaded
       if (apiSpecs.length === 0) {
         fetch('/api/specs')
-          .then((res) => res.json())
-          .then((specs) => { if (!cancelled) setApiSpecs(specs) })
-          .catch(() => {})
+          .then(res => res.json())
+          .then(specs => {
+            if (!cancelled.current) setApiSpecs(specs);
+          })
+          .catch(() => {});
       }
-      return () => { cancelled = true }
+      return () => { cancelled.current = true; };
     }
 
-    async function load() {
-      const slug = pathname === '/' ? [] : pathname.slice(1).split('/').filter(Boolean)
-
-      const [sourcePage, newTree] = await Promise.all([getPage(slug), buildPageTree()])
-      if (cancelled || !sourcePage) return
+    const slug = pathname === '/'
+      ? []
+      : pathname.slice(1).split('/').filter(Boolean);
 
-      const component = await loadPageComponent(sourcePage)
-      if (cancelled) return
+    const apiPath = slug.length === 0 ? '/api/page/' : `/api/page/${slug.join('/')}`;
 
-      setTree(newTree)
-      setPage({
-        slug,
-        frontmatter: sourcePage.frontmatter,
-        content: component ? React.createElement(component, { components: mdxComponents }) : null,
+    fetch(apiPath)
+      .then(res => res.json())
+      .then(async (data: { frontmatter: Frontmatter; relativePath: string }) => {
+        if (cancelled.current) return;
+        const { content, toc } = await loadMdx(data.relativePath);
+        if (cancelled.current) return;
+        setPage({ slug, frontmatter: data.frontmatter, content, toc });
       })
-    }
-    load()
-    return () => { cancelled = true }
-  }, [pathname])
+      .catch(() => {});
+
+    return () => { cancelled.current = true; };
+  }, [pathname]);
 
   return (
-    <PageContext.Provider value={{ config: initialConfig, tree, page, apiSpecs }}>
+    <PageContext.Provider
+      value={{ config: initialConfig, tree, page, apiSpecs }}
+    >
       {children}
     </PageContext.Provider>
-  )
+  );
 }