@raystack/chronicle 0.1.2 → 0.2.0

package/src/cli/commands/dev.ts

@@ -1,30 +1,37 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-declare const PACKAGE_ROOT: string
-
-const nextBin = path.join(PACKAGE_ROOT, 'node_modules', '.bin', process.platform === 'win32' ? 'next.cmd' : 'next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const devCommand = new Command('dev')
   .description('Start development server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('-c, --content <path>', 'Content directory')
   .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    let nextCli: string
+    try {
+      nextCli = resolveNextCli()
+    } catch {
+      console.log(chalk.red('Error: Next.js CLI not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
 
     console.log(chalk.cyan('Starting dev server...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
-    const child = spawn(nextBin, ['dev', '-p', options.port], {
+    const child = spawn(process.execPath, [nextCli, 'dev', '-p', options.port], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env: {
         ...process.env,
-        CHRONICLE_CONTENT_DIR: contentDir,
+        CHRONICLE_PROJECT_ROOT: process.cwd(),
+        CHRONICLE_CONTENT_DIR: './content',
       },
     })
 

package/src/cli/commands/init.ts

@@ -1,9 +1,12 @@
 import { Command } from 'commander'
+import { execSync } from 'child_process'
 import fs from 'fs'
 import path from 'path'
 import chalk from 'chalk'
 import { stringify } from 'yaml'
 import type { ChronicleConfig } from '@/types'
+import { loadCLIConfig, scaffoldDir, detectPackageManager, getChronicleVersion } from '@/cli/utils'
+
 
 function createConfig(): ChronicleConfig {
   return {
@@ -14,6 +17,29 @@ function createConfig(): ChronicleConfig {
   }
 }
 
+function createPackageJson(name: string): Record<string, unknown> {
+  return {
+    name,
+    private: true,
+    type: 'module',
+    scripts: {
+      dev: 'chronicle dev',
+      build: 'chronicle build',
+      start: 'chronicle start',
+    },
+    dependencies: {
+      '@raystack/chronicle': `^${getChronicleVersion()}`,
+    },
+    devDependencies: {
+      '@raystack/tools-config': '0.56.0',
+      'openapi-types': '^12.1.3',
+      typescript: '5.9.3',
+      '@types/react': '^19.2.10',
+      '@types/node': '^25.1.0',
+    },
+  }
+}
+
 const sampleMdx = `---
 title: Welcome
 description: Getting started with your documentation
@@ -27,18 +53,71 @@ This is your documentation home page.
 
 export const initCommand = new Command('init')
   .description('Initialize a new Chronicle project')
-  .option('-d, --dir <path>', 'Content directory', '.')
+  .option('-c, --content <path>', 'Content directory name', 'content')
   .action((options) => {
-    const contentDir = path.resolve(options.dir)
+    const projectDir = process.cwd()
+    const dirName = path.basename(projectDir) || 'docs'
+    const contentDir = path.join(projectDir, options.content)
 
-    // Create content directory
+    // Create content directory if it doesn't exist
     if (!fs.existsSync(contentDir)) {
       fs.mkdirSync(contentDir, { recursive: true })
       console.log(chalk.green('✓'), 'Created', contentDir)
     }
 
-    // Create chronicle.yaml
-    const configPath = path.join(contentDir, 'chronicle.yaml')
+    // Create or update package.json in project root
+    const packageJsonPath = path.join(projectDir, 'package.json')
+    if (!fs.existsSync(packageJsonPath)) {
+      fs.writeFileSync(packageJsonPath, JSON.stringify(createPackageJson(dirName), null, 2) + '\n')
+      console.log(chalk.green('✓'), 'Created', packageJsonPath)
+    } else {
+      const existing = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+      const template = createPackageJson(dirName)
+      let updated = false
+
+      // Set type to module
+      if (existing.type !== 'module') {
+        existing.type = 'module'
+        updated = true
+      }
+
+      // Merge missing scripts
+      if (!existing.scripts) existing.scripts = {}
+      for (const [key, value] of Object.entries(template.scripts as Record<string, string>)) {
+        if (!existing.scripts[key]) {
+          existing.scripts[key] = value
+          updated = true
+        }
+      }
+
+      // Merge missing dependencies
+      if (!existing.dependencies) existing.dependencies = {}
+      for (const [key, value] of Object.entries(template.dependencies as Record<string, string>)) {
+        if (!existing.dependencies[key]) {
+          existing.dependencies[key] = value
+          updated = true
+        }
+      }
+
+      // Merge missing devDependencies
+      if (!existing.devDependencies) existing.devDependencies = {}
+      for (const [key, value] of Object.entries(template.devDependencies as Record<string, string>)) {
+        if (!existing.devDependencies[key]) {
+          existing.devDependencies[key] = value
+          updated = true
+        }
+      }
+
+      if (updated) {
+        fs.writeFileSync(packageJsonPath, JSON.stringify(existing, null, 2) + '\n')
+        console.log(chalk.green('✓'), 'Updated', packageJsonPath, 'with missing scripts/deps')
+      } else {
+        console.log(chalk.yellow('⚠'), packageJsonPath, 'already has all required entries')
+      }
+    }
+
+    // Create chronicle.yaml in project root
+    const configPath = path.join(projectDir, 'chronicle.yaml')
     if (!fs.existsSync(configPath)) {
       fs.writeFileSync(configPath, stringify(createConfig()))
       console.log(chalk.green('✓'), 'Created', configPath)
@@ -46,13 +125,39 @@ export const initCommand = new Command('init')
       console.log(chalk.yellow('⚠'), configPath, 'already exists')
     }
 
-    // Create sample index.mdx
-    const indexPath = path.join(contentDir, 'index.mdx')
-    if (!fs.existsSync(indexPath)) {
+    // Create sample index.mdx only if content dir is empty
+    const contentFiles = fs.readdirSync(contentDir)
+    if (contentFiles.length === 0) {
+      const indexPath = path.join(contentDir, 'index.mdx')
       fs.writeFileSync(indexPath, sampleMdx)
       console.log(chalk.green('✓'), 'Created', indexPath)
     }
 
+    // Add entries to .gitignore
+    const gitignorePath = path.join(projectDir, '.gitignore')
+    const gitignoreEntries = ['.chronicle', 'node_modules', '.next']
+    if (fs.existsSync(gitignorePath)) {
+      const existing = fs.readFileSync(gitignorePath, 'utf-8')
+      const missing = gitignoreEntries.filter(e => !existing.includes(e))
+      if (missing.length > 0) {
+        fs.appendFileSync(gitignorePath, `\n${missing.join('\n')}\n`)
+        console.log(chalk.green('✓'), 'Added', missing.join(', '), 'to .gitignore')
+      }
+    } else {
+      fs.writeFileSync(gitignorePath, `${gitignoreEntries.join('\n')}\n`)
+      console.log(chalk.green('✓'), 'Created .gitignore')
+    }
+
+    // Install dependencies
+    const pm = detectPackageManager()
+    console.log(chalk.cyan(`\nInstalling dependencies with ${pm}...`))
+    execSync(`${pm} install`, { cwd: projectDir, stdio: 'inherit' })
+
+    // Scaffold .chronicle/ directory
+    loadCLIConfig(contentDir)
+    scaffoldDir(contentDir)
+
+    const runCmd = pm === 'npm' ? 'npx' : pm === 'bun' ? 'bunx' : `${pm} dlx`
     console.log(chalk.green('\n✓ Chronicle initialized!'))
-    console.log('\nRun', chalk.cyan('chronicle dev'), 'to start development server')
+    console.log('\nRun', chalk.cyan(`${runCmd} chronicle dev`), 'to start development server')
   })

package/src/cli/commands/serve.ts

@@ -1,32 +1,39 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-declare const PACKAGE_ROOT: string
-
-const nextBin = path.join(PACKAGE_ROOT, 'node_modules', '.bin', process.platform === 'win32' ? 'next.cmd' : 'next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const serveCommand = new Command('serve')
   .description('Build and start production server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('-c, --content <path>', 'Content directory')
   .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    let nextCli: string
+    try {
+      nextCli = resolveNextCli()
+    } catch {
+      console.log(chalk.red('Error: Next.js CLI not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
 
     const env = {
       ...process.env,
-      CHRONICLE_CONTENT_DIR: contentDir,
+      CHRONICLE_PROJECT_ROOT: process.cwd(),
+      CHRONICLE_CONTENT_DIR: './content',
     }
 
     console.log(chalk.cyan('Building for production...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
-    const buildChild = spawn(nextBin, ['build'], {
+    const buildChild = spawn(process.execPath, [nextCli, 'build'], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env,
     })
 
@@ -41,9 +48,9 @@ export const serveCommand = new Command('serve')
 
       console.log(chalk.cyan('Starting production server...'))
 
-      const startChild = spawn(nextBin, ['start', '-p', options.port], {
+      const startChild = spawn(process.execPath, [nextCli, 'start', '-p', options.port], {
         stdio: 'inherit',
-        cwd: PACKAGE_ROOT,
+        cwd: scaffoldPath,
         env,
       })
 

package/src/cli/commands/start.ts

@@ -1,30 +1,37 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-declare const PACKAGE_ROOT: string
-
-const nextBin = path.join(PACKAGE_ROOT, 'node_modules', '.bin', process.platform === 'win32' ? 'next.cmd' : 'next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const startCommand = new Command('start')
   .description('Start production server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('-c, --content <path>', 'Content directory')
   .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    let nextCli: string
+    try {
+      nextCli = resolveNextCli()
+    } catch {
+      console.log(chalk.red('Error: Next.js CLI not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
 
     console.log(chalk.cyan('Starting production server...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
-    const child = spawn(nextBin, ['start', '-p', options.port], {
+    const child = spawn(process.execPath, [nextCli, 'start', '-p', options.port], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env: {
         ...process.env,
-        CHRONICLE_CONTENT_DIR: contentDir,
+        CHRONICLE_PROJECT_ROOT: process.cwd(),
+        CHRONICLE_CONTENT_DIR: './content',
       },
     })
 

package/src/cli/utils/config.ts

@@ -13,14 +13,22 @@ export interface CLIConfig {
 export function resolveContentDir(contentFlag?: string): string {
   if (contentFlag) return path.resolve(contentFlag)
   if (process.env.CHRONICLE_CONTENT_DIR) return path.resolve(process.env.CHRONICLE_CONTENT_DIR)
-  return process.cwd()
+  return path.resolve('content')
+}
+
+function resolveConfigPath(contentDir: string): string | null {
+  const cwdPath = path.join(process.cwd(), 'chronicle.yaml')
+  if (fs.existsSync(cwdPath)) return cwdPath
+  const contentPath = path.join(contentDir, 'chronicle.yaml')
+  if (fs.existsSync(contentPath)) return contentPath
+  return null
 }
 
 export function loadCLIConfig(contentDir: string): CLIConfig {
-  const configPath = path.join(contentDir, 'chronicle.yaml')
+  const configPath = resolveConfigPath(contentDir)
 
-  if (!fs.existsSync(configPath)) {
-    console.log(chalk.red('Error: chronicle.yaml not found in'), contentDir)
+  if (!configPath) {
+    console.log(chalk.red(`Error: chronicle.yaml not found in '${process.cwd()}' or '${contentDir}'`))
     console.log(chalk.gray(`Run 'chronicle init' to create one`))
     process.exit(1)
   }

package/src/cli/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './config'
 export * from './process'
+export * from './scaffold'

package/src/cli/utils/resolve.ts

@@ -0,0 +1,6 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+// After bundling: dist/cli/index.js → ../.. = package root
+// After install: node_modules/@raystack/chronicle/dist/cli/index.js → ../.. = package root
+export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')

package/src/cli/utils/scaffold.ts

@@ -0,0 +1,137 @@
+import { execSync } from 'child_process'
+import { createRequire } from 'module'
+import fs from 'fs'
+import path from 'path'
+import chalk from 'chalk'
+import { PACKAGE_ROOT } from './resolve'
+
+const COPY_FILES = ['src', 'source.config.ts', 'tsconfig.json']
+
+function copyRecursive(src: string, dest: string) {
+  const stat = fs.statSync(src)
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true })
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry))
+    }
+  } else {
+    fs.copyFileSync(src, dest)
+  }
+}
+
+function ensureRemoved(targetPath: string) {
+  try {
+    fs.lstatSync(targetPath)
+    fs.rmSync(targetPath, { recursive: true, force: true })
+  } catch {
+    // nothing exists, proceed
+  }
+}
+
+export function detectPackageManager(): string {
+  if (process.env.npm_config_user_agent) {
+    return process.env.npm_config_user_agent.split('/')[0]
+  }
+  const cwd = process.cwd()
+  if (fs.existsSync(path.join(cwd, 'bun.lock')) || fs.existsSync(path.join(cwd, 'bun.lockb'))) return 'bun'
+  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn'
+  return 'npm'
+}
+
+function generateNextConfig(scaffoldPath: string) {
+  const config = `import { createMDX } from 'fumadocs-mdx/next'
+
+const withMDX = createMDX()
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+}
+
+export default withMDX(nextConfig)
+`
+  fs.writeFileSync(path.join(scaffoldPath, 'next.config.mjs'), config)
+}
+
+function createPackageJson(): Record<string, unknown> {
+  return {
+    name: 'chronicle-docs',
+    private: true,
+    dependencies: {
+      '@raystack/chronicle': `^${getChronicleVersion()}`,
+    },
+    devDependencies: {
+      '@raystack/tools-config': '0.56.0',
+      'openapi-types': '^12.1.3',
+      typescript: '5.9.3',
+      '@types/react': '^19.2.10',
+      '@types/node': '^25.1.0',
+    },
+  }
+}
+
+function ensureDeps() {
+  const cwd = process.cwd()
+  const cwdPkgJson = path.join(cwd, 'package.json')
+  const cwdNodeModules = path.join(cwd, 'node_modules')
+
+  if (fs.existsSync(cwdPkgJson) && fs.existsSync(cwdNodeModules)) {
+    // Case 1: existing project with deps installed
+    return
+  }
+
+  // Case 2: no package.json — create in cwd and install
+  if (!fs.existsSync(cwdPkgJson)) {
+    fs.writeFileSync(cwdPkgJson, JSON.stringify(createPackageJson(), null, 2) + '\n')
+  }
+
+  if (!fs.existsSync(cwdNodeModules)) {
+    const pm = detectPackageManager()
+    console.log(chalk.cyan(`Installing dependencies with ${pm}...`))
+    execSync(`${pm} install`, { cwd, stdio: 'inherit' })
+  }
+}
+
+export function getChronicleVersion(): string {
+  const pkgPath = path.join(PACKAGE_ROOT, 'package.json')
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+  return pkg.version
+}
+
+export function resolveNextCli(): string {
+  const chronicleRequire = createRequire(path.join(PACKAGE_ROOT, 'package.json'))
+  return chronicleRequire.resolve('next/dist/bin/next')
+}
+
+export function scaffoldDir(contentDir: string): string {
+  const scaffoldPath = path.join(process.cwd(), '.chronicle')
+
+  // Create .chronicle/ if not exists
+  if (!fs.existsSync(scaffoldPath)) {
+    fs.mkdirSync(scaffoldPath, { recursive: true })
+  }
+
+  // Copy package files
+  for (const name of COPY_FILES) {
+    const src = path.join(PACKAGE_ROOT, name)
+    const dest = path.join(scaffoldPath, name)
+    ensureRemoved(dest)
+    copyRecursive(src, dest)
+  }
+
+  // Generate next.config.mjs
+  generateNextConfig(scaffoldPath)
+
+  // Symlink content dir
+  const contentLink = path.join(scaffoldPath, 'content')
+  ensureRemoved(contentLink)
+  fs.symlinkSync(path.resolve(contentDir), contentLink)
+
+  // Ensure dependencies are available
+  ensureDeps()
+
+  console.log(chalk.gray(`Scaffold: ${scaffoldPath}`))
+
+  return scaffoldPath
+}

package/src/components/ui/search.module.css

@@ -102,3 +102,10 @@
 .item[data-selected="true"] .icon {
   color: var(--rs-color-foreground-accent-primary-hover);
 }
+
+.pageText :global(mark),
+.headingText :global(mark) {
+  background: transparent;
+  color: var(--rs-color-foreground-accent-primary);
+  font-weight: 600;
+}

package/src/components/ui/search.tsx

@@ -111,7 +111,7 @@ export function Search({ className }: SearchProps) {
                         <div className={styles.itemContent}>
                           {getResultIcon(result)}
                           <Text className={styles.pageText}>
-                            {stripMethod(result.content)}
+                            <HighlightedText html={stripMethod(result.content)} />
                           </Text>
                         </div>
                       </Command.Item>
@@ -132,7 +132,7 @@ export function Search({ className }: SearchProps) {
                         {result.type === "heading" ? (
                           <>
                             <Text className={styles.headingText}>
-                              {stripMethod(result.content)}
+                              <HighlightedText html={stripMethod(result.content)} />
                             </Text>
                             <Text className={styles.separator}>-</Text>
                             <Text className={styles.pageText}>
@@ -141,7 +141,7 @@ export function Search({ className }: SearchProps) {
                           </>
                         ) : (
                           <Text className={styles.pageText}>
-                            {stripMethod(result.content)}
+                            <HighlightedText html={stripMethod(result.content)} />
                           </Text>
                         )}
                       </div>
@@ -178,6 +178,10 @@ function stripMethod(content: string): string {
   return API_METHODS.has(first) ? content.slice(first.length + 1) : content;
 }
 
+function HighlightedText({ html, className }: { html: string; className?: string }) {
+  return <span className={className} dangerouslySetInnerHTML={{ __html: html }} />;
+}
+
 function getResultIcon(result: SortedResult): React.ReactNode {
   if (!result.url.startsWith("/apis/")) {
     return result.type === "page" ? (

package/src/lib/config.ts

@@ -11,11 +11,29 @@ const defaultConfig: ChronicleConfig = {
   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
+  if (contentDir) {
+    const contentPath = path.join(contentDir, CONFIG_FILE)
+    if (fs.existsSync(contentPath)) return contentPath
+  }
+  return null
+}
+
 export function loadConfig(): ChronicleConfig {
-  const dir = process.env.CHRONICLE_CONTENT_DIR ?? process.cwd()
-  const configPath = path.join(dir, CONFIG_FILE)
+  const configPath = resolveConfigPath()
 
-  if (!fs.existsSync(configPath)) {
+  if (!configPath) {
     return defaultConfig
   }
 
@@ -32,5 +50,6 @@ export function loadConfig(): ChronicleConfig {
     search: { ...defaultConfig.search, ...userConfig.search },
     footer: userConfig.footer,
     api: userConfig.api,
+    llms: { enabled: false, ...userConfig.llms },
   }
 }

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/remark-unused-directives.ts

@@ -2,26 +2,25 @@ import { visit } from 'unist-util-visit'
 import type { Plugin } from 'unified'
 import type { Node } from 'unist'
 
-interface DirectiveNode extends Node {
-  name?: string
-  attributes?: Record<string, string>
-  children?: Node[]
-  data?: unknown
-  [key: string]: unknown
-}
-
 const remarkUnusedDirectives: Plugin = () => {
   return (tree) => {
-    visit(tree, ['textDirective'], (node: DirectiveNode) => {
-      if (!node.data) {
-        const hasAttributes = node.attributes && Object.keys(node.attributes).length > 0
-        const hasChildren = node.children && node.children.length > 0
+    visit(tree, ['textDirective'], (node) => {
+      const directive = node as Node & {
+        name?: string
+        attributes?: Record<string, string>
+        children?: Node[]
+        value?: string
+        [key: string]: unknown
+      }
+      if (!directive.data) {
+        const hasAttributes = directive.attributes && Object.keys(directive.attributes).length > 0
+        const hasChildren = directive.children && directive.children.length > 0
         if (!hasAttributes && !hasChildren) {
-          const name = node.name
+          const name = directive.name
           if (!name) return
-          Object.keys(node).forEach((key) => delete node[key])
-          node.type = 'text'
-          node.value = `:${name}`
+          Object.keys(directive).forEach((key) => delete directive[key])
+          directive.type = 'text'
+          directive.value = `:${name}`
         }
       }
     })

package/src/lib/source.ts

@@ -1,4 +1,4 @@
-import { docs } from '../../.source/server'
+import { docs } from '@/.source/server'
 import { loader } from 'fumadocs-core/source'
 import type { PageTree, PageTreeItem, Frontmatter } from '@/types'
 
@@ -51,11 +51,12 @@ export function buildPageTree(): PageTree {
   const folderItems: PageTreeItem[] = []
   folders.forEach((items, folder) => {
     const sorted = sortByOrder(items)
-    const indexPage = sorted[0]
+    const indexPage = items.find(item => item.url === `/${folder}`)
+    const folderOrder = indexPage?.order ?? sorted[0]?.order
     folderItems.push({
       type: 'folder',
       name: folder.charAt(0).toUpperCase() + folder.slice(1),
-      order: indexPage?.order,
+      order: folderOrder,
       children: sorted,
     })
   })