mdcontext 0.0.1 → 0.2.0

package/src/summarize/verify-bugs.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Verification tests for the three token budget bugs
+ *
+ * Bug 1: Orphaned children - if parent is truncated, children are lost
+ * Bug 2: Token estimation inaccuracy - 4 chars/token can be ±30% off
+ * Bug 3: Formatting overhead under-estimated - 50 token reserve insufficient
+ */
+
+import { Effect } from 'effect'
+import { describe, expect, it } from 'vitest'
+import { countTokens, countTokensApprox } from '../utils/tokens.js'
+import { formatSummary } from './formatters.js'
+import type { DocumentSummary } from './summarizer.js'
+
+describe('verify token budget bugs', () => {
+  describe('Bug 1: Orphaned children', () => {
+    it('should rescue children when parent is too large', () => {
+      // Create a parent with a very large summary that won't fit budget
+      // but with small children that would fit
+      const mockSummary: DocumentSummary = {
+        path: '/test/file.md',
+        title: 'Test',
+        originalTokens: 1000,
+        summaryTokens: 500,
+        compressionRatio: 0.5,
+        sections: [
+          {
+            heading: 'Huge Parent',
+            level: 2,
+            originalTokens: 500,
+            summaryTokens: 400,
+            summary: 'Large content '.repeat(100), // ~400 tokens
+            children: [
+              {
+                heading: 'Tiny Child',
+                level: 3,
+                originalTokens: 20,
+                summaryTokens: 5,
+                summary: 'Small.',
+                children: [],
+                hasCode: false,
+                hasList: false,
+                hasTable: false,
+              },
+            ],
+            hasCode: false,
+            hasList: false,
+            hasTable: false,
+          },
+        ],
+        keyTopics: [],
+      }
+
+      // Budget can't fit parent (~400 tokens) but can fit child (~5 tokens)
+      // Increased to account for enhanced truncation warning with section lists
+      const output = formatSummary(mockSummary, { maxTokens: 180 })
+
+      // Child should be rescued even though parent doesn't fit
+      expect(output).toContain('Tiny Child')
+      // Parent should NOT be included
+      expect(output).not.toContain('Huge Parent')
+      expect(output).not.toContain('Large content')
+    })
+  })
+
+  describe('Bug 2: Token estimation accuracy', () => {
+    it('approximation should never under-count vs tiktoken', async () => {
+      const testCases = [
+        'Hello world, this is a simple test.',
+        '```typescript\nfunction foo() { return 42; }\n```',
+        '/very/long/path/to/deeply/nested/directory/structure/file.md',
+        '# Title\n\nSome prose with `code` and path /src/utils.ts.\n\n```js\nconst x = 1;\n```',
+        'Hello, world! How are you? Fine, thanks... Well: good! (Yes, really.)',
+        '这是中文文本测试。',
+        '👋 Hello 🌍 World 🎉',
+      ]
+
+      for (const text of testCases) {
+        const approx = countTokensApprox(text)
+        const actual = await Effect.runPromise(countTokens(text))
+
+        // CRITICAL: Approximation must NEVER be less than actual
+        // Under-counting causes budget violations
+        expect(approx).toBeGreaterThanOrEqual(actual)
+      }
+    })
+
+    it('approximation should be reasonably close (within 2x)', async () => {
+      const testCases = [
+        'Hello world, this is a simple test.',
+        '```typescript\nfunction foo() { return 42; }\n```',
+        '/very/long/path/to/deeply/nested/directory/structure/file.md',
+      ]
+
+      for (const text of testCases) {
+        const approx = countTokensApprox(text)
+        const actual = await Effect.runPromise(countTokens(text))
+
+        // Should not be more than 2x over-estimate
+        expect(approx).toBeLessThanOrEqual(actual * 2)
+      }
+    })
+  })
+
+  describe('Bug 3: Formatting overhead', () => {
+    it('output should stay within budget even with long paths', () => {
+      const mockSummary: DocumentSummary = {
+        path: '/very/long/path/to/some/deeply/nested/directory/structure/with/many/segments/file.md',
+        title:
+          'A Document With A Very Long Title That Takes Up Many Tokens In The Output',
+        originalTokens: 2000,
+        summaryTokens: 100,
+        compressionRatio: 0.95,
+        sections: [
+          {
+            heading: 'Section 1',
+            level: 2,
+            originalTokens: 100,
+            summaryTokens: 20,
+            summary: 'Some content.',
+            children: [],
+            hasCode: false,
+            hasList: false,
+            hasTable: false,
+          },
+        ],
+        keyTopics: [
+          'topic1',
+          'topic2',
+          'topic3',
+          'another-very-long-topic-name',
+          'yet-another-long-topic',
+        ],
+      }
+
+      const budgets = [100, 150, 200, 300]
+
+      for (const budget of budgets) {
+        const output = formatSummary(mockSummary, { maxTokens: budget })
+        const actualTokens = countTokensApprox(output)
+
+        expect(actualTokens).toBeLessThanOrEqual(budget)
+      }
+    })
+
+    it('output should stay within budget with many topics', () => {
+      const mockSummary: DocumentSummary = {
+        path: '/test/file.md',
+        title: 'Test Document',
+        originalTokens: 500,
+        summaryTokens: 50,
+        compressionRatio: 0.9,
+        sections: [],
+        keyTopics: [
+          'topic-one',
+          'topic-two',
+          'topic-three',
+          'topic-four',
+          'topic-five',
+          'topic-six',
+          'topic-seven',
+          'topic-eight',
+          'topic-nine',
+          'topic-ten',
+        ],
+      }
+
+      const output = formatSummary(mockSummary, { maxTokens: 100 })
+      const actualTokens = countTokensApprox(output)
+
+      expect(actualTokens).toBeLessThanOrEqual(100)
+    })
+  })
+
+  describe('strict budget enforcement', () => {
+    it('MUST stay within budget for realistic scenarios', () => {
+      const scenarios: DocumentSummary[] = [
+        {
+          // Scenario 1: Long path and title
+          path: '/project/src/components/deeply/nested/module/submodule/component.tsx',
+          title: 'A React Component With Authentication And Session Management',
+          originalTokens: 2000,
+          summaryTokens: 800,
+          compressionRatio: 0.6,
+          sections: [
+            {
+              heading: 'Overview',
+              level: 2,
+              originalTokens: 200,
+              summaryTokens: 80,
+              summary:
+                'This component handles user authentication and session management.',
+              children: [],
+              hasCode: false,
+              hasList: false,
+              hasTable: false,
+            },
+          ],
+          keyTopics: ['react', 'authentication', 'session', 'security'],
+        },
+        {
+          // Scenario 2: Code-heavy content
+          path: '/src/utils/parser.ts',
+          title: 'Parser Utilities',
+          originalTokens: 1500,
+          summaryTokens: 600,
+          compressionRatio: 0.6,
+          sections: [
+            {
+              heading: 'parse',
+              level: 2,
+              originalTokens: 500,
+              summaryTokens: 200,
+              summary:
+                '```typescript\nfunction parse(input: string): AST {\n  const tokens = tokenize(input);\n  return buildTree(tokens);\n}\n```',
+              children: [],
+              hasCode: true,
+              hasList: false,
+              hasTable: false,
+            },
+          ],
+          keyTopics: ['parser', 'ast', 'typescript'],
+        },
+      ]
+
+      const budgets = [100, 150, 200, 300, 500]
+
+      for (const scenario of scenarios) {
+        for (const budget of budgets) {
+          const output = formatSummary(scenario, { maxTokens: budget })
+          const actualTokens = countTokensApprox(output)
+
+          expect(actualTokens).toBeLessThanOrEqual(budget)
+        }
+      }
+    })
+  })
+})

package/src/types/huggingface-transformers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Type declarations for @huggingface/transformers (optional dependency)
+ *
+ * This package is an optional peer dependency used for cross-encoder re-ranking.
+ * Users who want re-ranking can install it with: npm install @huggingface/transformers
+ */
+
+declare module '@huggingface/transformers' {
+  export interface ProgressCallbackData {
+    file?: string
+    progress?: number
+  }
+
+  export type ProgressCallback = (data: ProgressCallbackData) => void
+
+  export interface AutoModelOptions {
+    progress_callback?: ProgressCallback | undefined
+  }
+
+  export interface AutoTokenizerOptions {
+    progress_callback?: ProgressCallback | undefined
+  }
+
+  export interface TokenizerOutput {
+    input_ids: unknown
+    attention_mask: unknown
+  }
+
+  export interface ModelOutput {
+    logits: {
+      data: Float32Array
+    }
+  }
+
+  export const env: {
+    cacheDir: string
+  }
+
+  export type AutoTokenizerInstance = (
+    texts: string[],
+    options: {
+      text_pair?: string[]
+      padding?: boolean
+      truncation?: boolean
+      max_length?: number
+    },
+  ) => TokenizerOutput
+
+  export type AutoModelInstance = (
+    input: TokenizerOutput,
+  ) => Promise<ModelOutput>
+
+  export const AutoTokenizer: {
+    from_pretrained(
+      model: string,
+      options?: AutoTokenizerOptions,
+    ): Promise<AutoTokenizerInstance>
+  }
+
+  export const AutoModelForSequenceClassification: {
+    from_pretrained(
+      model: string,
+      options?: AutoModelOptions,
+    ): Promise<AutoModelInstance>
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './tokens.js'

package/src/utils/tokens.test.ts

@@ -0,0 +1,142 @@
+import { Effect } from 'effect'
+import { describe, expect, it } from 'vitest'
+import { countTokens, countTokensApprox, countWords } from './tokens.js'
+
+describe('token utilities', () => {
+  describe('countWords', () => {
+    it('counts words in a simple sentence', () => {
+      expect(countWords('Hello world')).toBe(2)
+    })
+
+    it('handles empty string', () => {
+      expect(countWords('')).toBe(0)
+    })
+
+    it('handles whitespace only', () => {
+      expect(countWords('   ')).toBe(0)
+    })
+
+    it('handles multiple spaces between words', () => {
+      expect(countWords('hello    world')).toBe(2)
+    })
+
+    it('handles newlines and tabs', () => {
+      expect(countWords('hello\nworld\there')).toBe(3)
+    })
+  })
+
+  describe('countTokensApprox', () => {
+    it('estimates tokens for short text', () => {
+      // Approximation includes safety margin, so we check it's reasonable
+      const text = 'Hello world' // 11 chars
+      const estimate = countTokensApprox(text)
+      expect(estimate).toBeGreaterThan(0)
+      // With 20% safety margin, should be around 4-5 tokens
+      expect(estimate).toBeGreaterThanOrEqual(3)
+      expect(estimate).toBeLessThanOrEqual(10)
+    })
+
+    it('handles empty string', () => {
+      expect(countTokensApprox('')).toBe(0)
+    })
+
+    it('estimates longer text', () => {
+      const text =
+        'This is a longer piece of text that should have more tokens.'
+      const estimate = countTokensApprox(text)
+      expect(estimate).toBeGreaterThan(10)
+    })
+
+    it('is conservative for code blocks', () => {
+      const code = '```javascript\nfunction foo() {\n  return bar;\n}\n```'
+      const estimate = countTokensApprox(code)
+      // Code block is ~50 chars, actual tiktoken count is 13 tokens
+      // Estimate should be >= actual (conservative) - we prioritize never under-counting
+      // for budget enforcement, so we allow up to 100% over-estimation
+      expect(estimate).toBeGreaterThanOrEqual(13)
+      expect(estimate).toBeLessThanOrEqual(26) // up to 2x actual
+    })
+
+    it('accounts for punctuation', () => {
+      const textWithPunctuation = 'Hello, world! How are you? Fine, thanks.'
+      const plainText = 'Hello world How are you Fine thanks'
+      const withPunc = countTokensApprox(textWithPunctuation)
+      const withoutPunc = countTokensApprox(plainText)
+      // Punctuation should add some token overhead
+      expect(withPunc).toBeGreaterThan(withoutPunc)
+    })
+
+    it('accounts for newlines', () => {
+      const singleLine = 'Hello world'
+      const multiLine = 'Hello\nworld'
+      const singleEst = countTokensApprox(singleLine)
+      const multiEst = countTokensApprox(multiLine)
+      // Newlines add token overhead
+      expect(multiEst).toBeGreaterThanOrEqual(singleEst)
+    })
+  })
+
+  describe('countTokensApprox accuracy vs tiktoken', () => {
+    // These tests verify the approximation is conservative (never under-estimates)
+    // We allow up to 2x over-estimation to ensure we NEVER violate token budgets
+    // Being over is safe (wastes some budget), under is dangerous (budget violations)
+
+    it('is conservative (never under-estimates) for prose', async () => {
+      const text =
+        'This is a simple sentence with some common words that form a typical paragraph.'
+      const approx = countTokensApprox(text)
+      const actual = await Effect.runPromise(countTokens(text))
+      // Approximation should be >= actual (conservative) - this is the critical requirement
+      expect(approx).toBeGreaterThanOrEqual(actual)
+      // Allow up to 2x over to ensure we never under-count
+      expect(approx).toBeLessThanOrEqual(actual * 2)
+    })
+
+    it('is conservative for code blocks', async () => {
+      const code =
+        '```typescript\nfunction parseDocument(input: string): AST {\n  const tokens = tokenize(input);\n  return buildTree(tokens);\n}\n```'
+      const approx = countTokensApprox(code)
+      const actual = await Effect.runPromise(countTokens(code))
+      // Approximation should be >= actual (conservative)
+      expect(approx).toBeGreaterThanOrEqual(actual)
+      // Allow up to 2.5x for code blocks (they're hardest to estimate)
+      expect(approx).toBeLessThanOrEqual(actual * 2.5)
+    })
+
+    it('is conservative for inline code', async () => {
+      const text =
+        'Use the `countTokens` function to count tokens in a `string`.'
+      const approx = countTokensApprox(text)
+      const actual = await Effect.runPromise(countTokens(text))
+      expect(approx).toBeGreaterThanOrEqual(actual)
+      expect(approx).toBeLessThanOrEqual(actual * 2)
+    })
+
+    it('is conservative for file paths', async () => {
+      const path =
+        '/very/long/path/to/deeply/nested/directory/structure/that/keeps/going/file.md'
+      const approx = countTokensApprox(path)
+      const actual = await Effect.runPromise(countTokens(path))
+      expect(approx).toBeGreaterThanOrEqual(actual)
+      expect(approx).toBeLessThanOrEqual(actual * 2)
+    })
+
+    it('is conservative for mixed content', async () => {
+      const text =
+        '# Title\n\nSome prose with `code` and a path `/src/utils.ts`.\n\n```js\nconst x = 1;\n```'
+      const approx = countTokensApprox(text)
+      const actual = await Effect.runPromise(countTokens(text))
+      expect(approx).toBeGreaterThanOrEqual(actual)
+      expect(approx).toBeLessThanOrEqual(actual * 2)
+    })
+
+    it('is conservative for punctuation-heavy text', async () => {
+      const text =
+        'Hello, world! How are you? Fine, thanks... Well: good! (Yes, really.)'
+      const approx = countTokensApprox(text)
+      const actual = await Effect.runPromise(countTokens(text))
+      expect(approx).toBeGreaterThanOrEqual(actual)
+      expect(approx).toBeLessThanOrEqual(actual * 2)
+    })
+  })
+})

package/src/utils/tokens.ts

@@ -0,0 +1,186 @@
+/**
+ * Token counting utilities using tiktoken
+ */
+
+import { Effect } from 'effect'
+
+// Lazy-loaded tiktoken encoder
+let encoder: Awaited<
+  ReturnType<typeof import('tiktoken').get_encoding>
+> | null = null
+
+const getEncoder = Effect.gen(function* () {
+  if (encoder === null) {
+    const { get_encoding } = yield* Effect.promise(() => import('tiktoken'))
+    encoder = get_encoding('cl100k_base')
+  }
+  return encoder
+})
+
+/**
+ * Count tokens in a string using the cl100k_base encoding
+ * (compatible with GPT-4, GPT-3.5-turbo, and Claude models)
+ */
+export const countTokens = (
+  text: string,
+): Effect.Effect<number, never, never> =>
+  Effect.gen(function* () {
+    const enc = yield* getEncoder
+    const tokens = enc.encode(text)
+    return tokens.length
+  })
+
+/**
+ * Synchronous token counting with improved approximation
+ *
+ * Uses heuristics calibrated against cl100k_base encoding:
+ * - Base prose: ~3.5 chars/token (conservative to never under-count)
+ * - Code blocks: Content at ~2.8 chars/token + fixed overhead per block
+ * - Inline code: ~2.5 chars/token + 2 tokens per backtick pair
+ * - Paths: ~3.0 chars/token (slashes tokenize separately)
+ * - Newlines: ~1 token each (they often become separate tokens)
+ * - Punctuation/symbols: adds ~0.8 tokens per mark
+ * - CJK characters: ~1.2 tokens per character
+ * - Emojis: ~2.5 tokens per emoji
+ *
+ * Safety margin of 10% to handle edge cases and ensure budget compliance.
+ * The conservative ratios combined with safety margin ensure we NEVER under-count.
+ */
+export const countTokensApprox = (text: string): number => {
+  if (text.length === 0) return 0
+
+  // Count CJK characters (Chinese, Japanese, Korean)
+  // These typically tokenize to 1-2 tokens per character
+  // Unicode ranges: CJK Unified Ideographs, Hiragana, Katakana, Hangul
+  const cjkPattern =
+    /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u3400-\u4dbf]/g
+  const cjkMatches = text.match(cjkPattern) || []
+  const cjkCount = cjkMatches.length
+
+  // Count emojis and symbols (they often tokenize to 2-4 tokens each)
+  // This pattern catches most common emojis, symbols, and dingbats
+  // Also count variation selectors (FE0E/FE0F) which add extra tokens
+  const emojiPattern =
+    /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2300}-\u{23FF}\u{2190}-\u{21FF}\u{25A0}-\u{25FF}\u{2B00}-\u{2BFF}]/gu
+  const emojiMatches = text.match(emojiPattern) || []
+  const emojiCount = emojiMatches.length
+
+  // Count variation selectors (they add extra tokens to base characters)
+  const variationSelectorPattern = /[\uFE0E\uFE0F]/g
+  const variationMatches = text.match(variationSelectorPattern) || []
+  const variationCount = variationMatches.length
+
+  // Extract and analyze code blocks
+  // Each code block has fixed overhead: ``` markers + language identifier
+  let workingText = text
+  const codeBlockMatches = text.match(/```[\s\S]*?```/g) || []
+  let codeBlockTokens = 0
+
+  for (const block of codeBlockMatches) {
+    // Check if it has a language identifier
+    const hasLang = /^```\w+/.test(block)
+    // Fixed overhead: opening backticks (1) + lang (1-2) + newline after lang (1) + closing backticks (1) + newline before close (1)
+    const overhead = hasLang ? 6 : 4
+    // Content between backticks (excluding the markers themselves)
+    const content = block.replace(/^```\w*\n?/, '').replace(/\n?```$/, '')
+    // Content newlines - each is typically 1 token
+    const contentNewlines = (content.match(/\n/g) || []).length
+    // Code content at ~2.5 chars/token (code has many symbols that become separate tokens)
+    const contentTokens = content.length > 0 ? content.length / 2.5 : 0
+    // Minimum 6 tokens for any code block (overhead alone)
+    codeBlockTokens += Math.max(
+      overhead,
+      overhead + contentNewlines + contentTokens,
+    )
+    workingText = workingText.replace(block, '')
+  }
+
+  // Extract inline code from the remaining text (single backticks)
+  const inlineCodeMatches = workingText.match(/`[^`]+`/g) || []
+  let inlineCodeTokens = 0
+  for (const match of inlineCodeMatches) {
+    // Each inline code has 2 tokens overhead (opening and closing backticks)
+    const content = match.slice(1, -1)
+    inlineCodeTokens += 2 + content.length / 2.5
+    workingText = workingText.replace(match, '')
+  }
+
+  // Count path-like sequences (consecutive /word patterns)
+  const pathMatches = workingText.match(/(?:\/[\w.-]+)+/g) || []
+  let pathTokens = 0
+  for (const match of pathMatches) {
+    // Each slash is typically a separate token, plus the path segments
+    const slashCount = (match.match(/\//g) || []).length
+    const contentLength = match.length - slashCount
+    pathTokens += slashCount + contentLength / 3.5
+    workingText = workingText.replace(match, '')
+  }
+
+  // Count punctuation and symbols in prose - these often become separate tokens
+  // Include more symbol characters that commonly appear in technical content
+  const punctuationMatches =
+    workingText.match(/[!?,.:;'"()[\]{}@#$%^&*+=|\\<>~\-/]/g) || []
+  const punctuationCount = punctuationMatches.length
+
+  // Count newlines in remaining prose
+  const proseNewlines = (workingText.match(/\n/g) || []).length
+
+  // Remaining prose length (excluding special characters already counted)
+  const proseLength = Math.max(
+    0,
+    workingText.length -
+      proseNewlines -
+      cjkCount -
+      emojiCount -
+      variationCount -
+      punctuationCount,
+  )
+
+  // Estimate tokens with calibrated ratios:
+  // - ASCII prose: ~3.5 chars/token (conservative - actual is ~4-5 but we want safety margin)
+  // - Newlines in prose: ~1 token each
+  // - Punctuation: ~0.8 tokens per mark (most become separate tokens or affect adjacent)
+  // - CJK: ~1.2 tokens per character (conservative estimate)
+  // - Emojis: ~2.5 tokens per emoji (conservative for compound emojis)
+  // - Variation selectors: ~1 token each
+  const proseTokens = proseLength / 3.5
+  const proseNewlineTokens = proseNewlines * 1
+  const punctuationBonus = punctuationCount * 0.8
+  const cjkTokens = cjkCount * 1.2
+  const emojiTokens = emojiCount * 2.5
+  const variationTokens = variationCount * 1
+
+  const estimate =
+    proseTokens +
+    proseNewlineTokens +
+    codeBlockTokens +
+    inlineCodeTokens +
+    pathTokens +
+    punctuationBonus +
+    cjkTokens +
+    emojiTokens +
+    variationTokens
+
+  // Add 10% safety margin to ensure we never under-count (critical for budget enforcement)
+  return Math.ceil(estimate * 1.1)
+}
+
+/**
+ * Count words in text
+ */
+export const countWords = (text: string): number => {
+  const trimmed = text.trim()
+  if (trimmed.length === 0) return 0
+  return trimmed.split(/\s+/).length
+}
+
+/**
+ * Free the tiktoken encoder to release WebAssembly resources.
+ * Call this in test teardown to prevent process hang.
+ */
+export const freeEncoder = (): void => {
+  if (encoder !== null) {
+    encoder.free()
+    encoder = null
+  }
+}

package/tests/fixtures/cli/.mdcontext/active-provider.json

@@ -0,0 +1,7 @@
+{
+  "namespace": "openai_text-embedding-3-small_512",
+  "provider": "openai",
+  "model": "text-embedding-3-small",
+  "dimensions": 512,
+  "activatedAt": "2026-01-27T07:43:50.361Z"
+}

package/tests/fixtures/cli/.mdcontext/config.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "rootPath": "/Users/alphab/Dev/LLM/DEV/mdcontext/tests/fixtures/cli",
+  "include": ["**/*.md", "**/*.mdx"],
+  "exclude": ["**/node_modules/**", "**/.*/**"],
+  "createdAt": "2026-01-21T16:49:02.823Z",
+  "updatedAt": "2026-01-21T16:49:02.823Z"
+}

package/tests/fixtures/cli/.mdcontext/indexes/documents.json

@@ -0,0 +1,33 @@
+{
+  "version": 1,
+  "rootPath": "tests/fixtures/cli",
+  "documents": {
+    "README.md": {
+      "id": "04c6e90faac2",
+      "path": "README.md",
+      "title": "Test Project",
+      "mtime": 1769492431399,
+      "hash": "54872b0fdbf6858a",
+      "tokenCount": 76,
+      "sectionCount": 2
+    },
+    "api-reference.md": {
+      "id": "392e93c0f22d",
+      "path": "api-reference.md",
+      "title": "API Reference",
+      "mtime": 1769492431399,
+      "hash": "4a879da54a831235",
+      "tokenCount": 109,
+      "sectionCount": 2
+    },
+    "getting-started.md": {
+      "id": "b6885e1f8555",
+      "path": "getting-started.md",
+      "title": "Getting Started",
+      "mtime": 1769492431400,
+      "hash": "2d44a41d5d2579f2",
+      "tokenCount": 66,
+      "sectionCount": 3
+    }
+  }
+}