@codragraph/cli 1.6.2

package/dist/core/embeddings/http-client.js

@@ -0,0 +1,179 @@
+/**
+ * HTTP Embedding Client
+ *
+ * Shared fetch+retry logic for OpenAI-compatible /v1/embeddings endpoints.
+ * Imported by both the core embedder (batch) and MCP embedder (query).
+ */
+const HTTP_TIMEOUT_MS = 30_000;
+const HTTP_MAX_RETRIES = 2;
+const HTTP_RETRY_BACKOFF_MS = 1_000;
+const HTTP_BATCH_SIZE = 64;
+const DEFAULT_DIMS = 384;
+/**
+ * Build config from the current process.env snapshot.
+ * Returns null when CODRAGRAPH_EMBEDDING_URL + CODRAGRAPH_EMBEDDING_MODEL are unset.
+ * Not cached — env vars are read fresh so late configuration takes effect.
+ */
+const readConfig = () => {
+    const baseUrl = process.env.CODRAGRAPH_EMBEDDING_URL;
+    const model = process.env.CODRAGRAPH_EMBEDDING_MODEL;
+    if (!baseUrl || !model)
+        return null;
+    const rawDims = process.env.CODRAGRAPH_EMBEDDING_DIMS;
+    let dimensions;
+    if (rawDims !== undefined) {
+        const parsed = parseInt(rawDims, 10);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            throw new Error(`CODRAGRAPH_EMBEDDING_DIMS must be a positive integer, got "${rawDims}"`);
+        }
+        dimensions = parsed;
+    }
+    return {
+        baseUrl: baseUrl.replace(/\/+$/, ''),
+        model,
+        apiKey: process.env.CODRAGRAPH_EMBEDDING_API_KEY ?? 'unused',
+        dimensions,
+    };
+};
+/**
+ * Check whether HTTP embedding mode is active (env vars are set).
+ */
+export const isHttpMode = () => readConfig() !== null;
+/**
+ * Return the configured embedding dimensions for HTTP mode, or undefined
+ * if HTTP mode is not active or no explicit dimensions are set.
+ */
+export const getHttpDimensions = () => readConfig()?.dimensions;
+/**
+ * Return a safe representation of a URL for error messages.
+ * Strips query string (may contain tokens) and userinfo.
+ */
+const safeUrl = (url) => {
+    try {
+        const u = new URL(url);
+        return `${u.protocol}//${u.host}${u.pathname}`;
+    }
+    catch {
+        return '<invalid-url>';
+    }
+};
+/**
+ * Send a single batch of texts to the embedding endpoint with retry.
+ *
+ * @param url - Full endpoint URL (e.g. https://host/v1/embeddings)
+ * @param batch - Texts to embed
+ * @param model - Model name for the request body
+ * @param apiKey - Bearer token (only used in Authorization header)
+ * @param batchIndex - Logical batch number (for error context)
+ * @param attempt - Current retry attempt (internal)
+ */
+const httpEmbedBatch = async (url, batch, model, apiKey, batchIndex = 0, attempt = 0) => {
+    let resp;
+    try {
+        resp = await fetch(url, {
+            method: 'POST',
+            signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({ input: batch, model }),
+        });
+    }
+    catch (err) {
+        // Timeouts should not be retried — the server is unresponsive.
+        // AbortSignal.timeout() throws DOMException with name 'TimeoutError'.
+        const isTimeout = err instanceof DOMException && err.name === 'TimeoutError';
+        if (isTimeout) {
+            throw new Error(`Embedding request timed out after ${HTTP_TIMEOUT_MS}ms (${safeUrl(url)}, batch ${batchIndex})`);
+        }
+        // DNS, connection errors — retry with backoff
+        if (attempt < HTTP_MAX_RETRIES) {
+            const delay = HTTP_RETRY_BACKOFF_MS * (attempt + 1);
+            await new Promise((r) => setTimeout(r, delay));
+            return httpEmbedBatch(url, batch, model, apiKey, batchIndex, attempt + 1);
+        }
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`Embedding request failed (${safeUrl(url)}, batch ${batchIndex}): ${reason}`);
+    }
+    if (!resp.ok) {
+        const status = resp.status;
+        if ((status === 429 || status >= 500) && attempt < HTTP_MAX_RETRIES) {
+            const delay = HTTP_RETRY_BACKOFF_MS * (attempt + 1);
+            await new Promise((r) => setTimeout(r, delay));
+            return httpEmbedBatch(url, batch, model, apiKey, batchIndex, attempt + 1);
+        }
+        throw new Error(`Embedding endpoint returned ${status} (${safeUrl(url)}, batch ${batchIndex})`);
+    }
+    const data = (await resp.json());
+    return data.data;
+};
+/**
+ * Embed texts via the HTTP backend, splitting into batches.
+ * Reads config from env vars on every call.
+ *
+ * @param texts - Array of texts to embed
+ * @returns Array of Float32Array embedding vectors
+ */
+export const httpEmbed = async (texts) => {
+    if (texts.length === 0)
+        return [];
+    const config = readConfig();
+    if (!config)
+        throw new Error('HTTP embedding not configured');
+    const url = `${config.baseUrl}/embeddings`;
+    const allVectors = [];
+    for (let i = 0; i < texts.length; i += HTTP_BATCH_SIZE) {
+        const batch = texts.slice(i, i + HTTP_BATCH_SIZE);
+        const batchIndex = Math.floor(i / HTTP_BATCH_SIZE);
+        const items = await httpEmbedBatch(url, batch, config.model, config.apiKey, batchIndex);
+        if (items.length !== batch.length) {
+            throw new Error(`Embedding endpoint returned ${items.length} vectors for ${batch.length} texts ` +
+                `(${safeUrl(url)}, batch ${batchIndex})`);
+        }
+        for (const item of items) {
+            const vec = new Float32Array(item.embedding);
+            // Fail fast on dimension mismatch rather than inserting bad vectors
+            // into the FLOAT[N] column which would cause a cryptic Kuzu error.
+            const expected = config.dimensions ?? DEFAULT_DIMS;
+            if (vec.length !== expected) {
+                const hint = config.dimensions
+                    ? 'Update CODRAGRAPH_EMBEDDING_DIMS to match your model output.'
+                    : `Set CODRAGRAPH_EMBEDDING_DIMS=${vec.length} to match your model output.`;
+                throw new Error(`Embedding dimension mismatch: endpoint returned ${vec.length}d vector, ` +
+                    `but expected ${expected}d. ${hint}`);
+            }
+            allVectors.push(vec);
+        }
+    }
+    return allVectors;
+};
+/**
+ * Embed a single query text via the HTTP backend.
+ * Convenience for MCP search where only one vector is needed.
+ *
+ * @param text - Query text to embed
+ * @returns Embedding vector as number array
+ */
+export const httpEmbedQuery = async (text) => {
+    const config = readConfig();
+    if (!config)
+        throw new Error('HTTP embedding not configured');
+    const url = `${config.baseUrl}/embeddings`;
+    const items = await httpEmbedBatch(url, [text], config.model, config.apiKey);
+    if (!items.length) {
+        throw new Error(`Embedding endpoint returned empty response (${safeUrl(url)})`);
+    }
+    const embedding = items[0].embedding;
+    // Same dimension checks as httpEmbed — catch mismatches before they
+    // reach the Kuzu FLOAT[N] cast in search queries.
+    const expected = config.dimensions ?? DEFAULT_DIMS;
+    if (embedding.length !== expected) {
+        const hint = config.dimensions
+            ? 'Update CODRAGRAPH_EMBEDDING_DIMS to match your model output.'
+            : `Set CODRAGRAPH_EMBEDDING_DIMS=${embedding.length} to match your model output.`;
+        throw new Error(`Embedding dimension mismatch: endpoint returned ${embedding.length}d vector, ` +
+            `but expected ${expected}d. ${hint}`);
+    }
+    return embedding;
+};

package/dist/core/embeddings/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Embeddings Module
+ *
+ * Re-exports for the embedding pipeline system.
+ */
+export * from './types.js';
+export * from './http-client.js';
+export * from './embedder.js';
+export * from './text-generator.js';
+export * from './embedding-pipeline.js';

package/dist/core/embeddings/index.js

@@ -0,0 +1,10 @@
+/**
+ * Embeddings Module
+ *
+ * Re-exports for the embedding pipeline system.
+ */
+export * from './types.js';
+export * from './http-client.js';
+export * from './embedder.js';
+export * from './text-generator.js';
+export * from './embedding-pipeline.js';

package/dist/core/embeddings/line-index.d.ts

@@ -0,0 +1,7 @@
+export interface ResolvedLineRange {
+    startLine: number;
+    endLine: number;
+}
+export declare const buildLineIndex: (content: string) => Int32Array;
+export declare const lineFromOffset: (lineOffsets: Int32Array, charOffset: number) => number;
+export declare const resolveChunkLines: (lineOffsets: Int32Array, startOffset: number, endOffset: number, baseStartLine: number) => ResolvedLineRange;

package/dist/core/embeddings/line-index.js

@@ -0,0 +1,42 @@
+export const buildLineIndex = (content) => {
+    const offsets = [0];
+    for (let i = 0; i < content.length; i++) {
+        if (content.charCodeAt(i) === 10)
+            offsets.push(i + 1);
+    }
+    return new Int32Array(offsets);
+};
+const clampOffset = (lineOffsets, charOffset) => {
+    if (lineOffsets.length === 0)
+        return 0;
+    const maxOffset = lineOffsets[lineOffsets.length - 1];
+    if (charOffset < 0)
+        return 0;
+    if (charOffset > maxOffset)
+        return maxOffset;
+    return charOffset;
+};
+export const lineFromOffset = (lineOffsets, charOffset) => {
+    if (lineOffsets.length === 0)
+        return 0;
+    const clamped = clampOffset(lineOffsets, charOffset);
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (lineOffsets[mid] <= clamped)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return lo;
+};
+export const resolveChunkLines = (lineOffsets, startOffset, endOffset, baseStartLine) => {
+    const relativeStartLine = lineFromOffset(lineOffsets, startOffset);
+    const effectiveEndOffset = endOffset > startOffset ? endOffset - 1 : startOffset;
+    const relativeEndLine = lineFromOffset(lineOffsets, effectiveEndOffset);
+    return {
+        startLine: baseStartLine + relativeStartLine,
+        endLine: baseStartLine + relativeEndLine,
+    };
+};

package/dist/core/embeddings/server-mapping.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Server Mapping Configuration
+ *
+ * Reads ~/.codragraph/server-mapping.json to map repo names to service names.
+ * Used in embedding text to enrich metadata with microservice context.
+ */
+/**
+ * Read the server mapping file and return the serverName for a given repoName.
+ * Returns undefined if no mapping exists.
+ */
+export declare const readServerMapping: (repoName: string) => Promise<string | undefined>;
+/**
+ * Clear the cached mapping (useful for testing or after file changes)
+ */
+export declare const clearServerMappingCache: () => void;

package/dist/core/embeddings/server-mapping.js

@@ -0,0 +1,33 @@
+/**
+ * Server Mapping Configuration
+ *
+ * Reads ~/.codragraph/server-mapping.json to map repo names to service names.
+ * Used in embedding text to enrich metadata with microservice context.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const MAPPING_FILE = path.join(os.homedir(), '.codragraph', 'server-mapping.json');
+let cachedMapping = null;
+/**
+ * Read the server mapping file and return the serverName for a given repoName.
+ * Returns undefined if no mapping exists.
+ */
+export const readServerMapping = async (repoName) => {
+    try {
+        if (!cachedMapping) {
+            const raw = await fs.readFile(MAPPING_FILE, 'utf-8');
+            cachedMapping = JSON.parse(raw);
+        }
+        return cachedMapping[repoName];
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Clear the cached mapping (useful for testing or after file changes)
+ */
+export const clearServerMappingCache = () => {
+    cachedMapping = null;
+};

package/dist/core/embeddings/structural-extractor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Structural Extractor Module
+ *
+ * Reuses ingestion pipeline's AST-based MethodExtractor / FieldExtractor
+ * to extract method and field names for embedding text generation.
+ */
+export interface StructuralNames {
+    methodNames: string[];
+    fieldNames: string[];
+}
+/**
+ * Extract method and field names from a class/struct/interface node
+ * using the ingestion pipeline's AST extractors.
+ */
+export declare const extractStructuralNames: (content: string, filePath: string) => Promise<StructuralNames>;

package/dist/core/embeddings/structural-extractor.js

@@ -0,0 +1,58 @@
+/**
+ * Structural Extractor Module
+ *
+ * Reuses ingestion pipeline's AST-based MethodExtractor / FieldExtractor
+ * to extract method and field names for embedding text generation.
+ */
+import { getProviderForFile } from '../ingestion/languages/index.js';
+import { buildTypeEnv } from '../ingestion/type-env.js';
+import { ensureAndParse, findDeclarationNode } from './ast-utils.js';
+const NOOP_SYMBOL_TABLE = {
+    lookupExactAll: () => [],
+    lookupExact: () => undefined,
+    lookupExactFull: () => undefined,
+};
+/**
+ * Extract method and field names from a class/struct/interface node
+ * using the ingestion pipeline's AST extractors.
+ */
+export const extractStructuralNames = async (content, filePath) => {
+    const provider = getProviderForFile(filePath);
+    if (!provider)
+        return { methodNames: [], fieldNames: [] };
+    const tree = await ensureAndParse(content, filePath);
+    if (!tree)
+        return { methodNames: [], fieldNames: [] };
+    // Parse node.content (a snippet) — find declaration directly, not by range
+    const classNode = findDeclarationNode(tree.rootNode);
+    if (!classNode)
+        return { methodNames: [], fieldNames: [] };
+    const language = provider.id;
+    const methodNames = extractMethodNames(classNode, provider, filePath, language);
+    const fieldNames = extractFieldNames(classNode, provider, tree, filePath, language);
+    return { methodNames, fieldNames };
+};
+function extractMethodNames(classNode, provider, filePath, language) {
+    if (!provider.methodExtractor)
+        return [];
+    const context = { filePath, language };
+    const result = provider.methodExtractor.extract(classNode, context);
+    if (!result?.methods?.length)
+        return [];
+    return result.methods.map((m) => m.name);
+}
+function extractFieldNames(classNode, provider, tree, filePath, language) {
+    if (!provider.fieldExtractor)
+        return [];
+    const typeEnv = buildTypeEnv(tree, language);
+    const context = {
+        typeEnv,
+        symbolTable: NOOP_SYMBOL_TABLE,
+        filePath,
+        language,
+    };
+    const result = provider.fieldExtractor.extract(classNode, context);
+    if (!result?.fields?.length)
+        return [];
+    return result.fields.map((f) => f.name);
+}

package/dist/core/embeddings/text-generator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Text Generator Module
+ *
+ * Generates enriched embedding text from code nodes with metadata.
+ * Supports chunkable labels (Function/Method with AST chunking),
+ * Class-specific structural text, and short-node direct embed.
+ *
+ * Method/field names for Class nodes are extracted by the ingestion
+ * pipeline's AST extractors and passed via node.methodNames/node.fieldNames.
+ */
+import type { EmbeddableNode, EmbeddingConfig } from './types.js';
+/**
+ * Truncate description to max length at sentence/word boundary
+ */
+declare const truncateDescription: (text: string, maxLength: number) => string;
+/**
+ * Extract class/interface/struct declaration lines, skipping method bodies.
+ * - Brace-based languages: detects method signatures (lines with `(` and `{`)
+ *   and skips until depth returns to class body level.
+ * - Non-brace languages (Python/Ruby): returns empty string (patterns handle extraction).
+ */
+export declare const extractDeclarationOnly: (content: string) => string;
+/**
+ * Generate embedding text for any embeddable node
+ * Dispatches to the appropriate generator based on node label
+ */
+export declare const generateEmbeddingText: (node: EmbeddableNode, codeBody: string, config?: Partial<EmbeddingConfig>, chunkIndex?: number, prevTail?: string) => string;
+/**
+ * Export truncation helper for testing
+ */
+export { truncateDescription };

package/dist/core/embeddings/text-generator.js

@@ -0,0 +1,208 @@
+/**
+ * Text Generator Module
+ *
+ * Generates enriched embedding text from code nodes with metadata.
+ * Supports chunkable labels (Function/Method with AST chunking),
+ * Class-specific structural text, and short-node direct embed.
+ *
+ * Method/field names for Class nodes are extracted by the ingestion
+ * pipeline's AST extractors and passed via node.methodNames/node.fieldNames.
+ */
+import { CHUNKING_RULES, DEFAULT_EMBEDDING_CONFIG, STRUCTURAL_TEXT_MODE_DECLARATION, isShortLabel, } from './types.js';
+/**
+ * Truncate description to max length at sentence/word boundary
+ */
+const truncateDescription = (text, maxLength) => {
+    if (text.length <= maxLength)
+        return text;
+    const truncated = text.slice(0, maxLength);
+    // Try sentence boundary (. ! ?)
+    const sentenceEnd = Math.max(truncated.lastIndexOf('. '), truncated.lastIndexOf('! '), truncated.lastIndexOf('? '));
+    if (sentenceEnd > maxLength * 0.5) {
+        return truncated.slice(0, sentenceEnd + 1);
+    }
+    // Try word boundary
+    const lastSpace = truncated.lastIndexOf(' ');
+    if (lastSpace > maxLength * 0.5) {
+        return truncated.slice(0, lastSpace);
+    }
+    return truncated;
+};
+/**
+ * Clean code content for embedding
+ */
+const cleanContent = (content) => {
+    return content
+        .replace(/\r\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .split('\n')
+        .map((line) => line.trimEnd())
+        .join('\n')
+        .trim();
+};
+/**
+ * Build metadata header for a node
+ */
+const buildMetadataHeader = (node, config) => {
+    const parts = [];
+    // Label + name
+    parts.push(`${node.label}: ${node.name}`);
+    // Repo name
+    if (node.repoName) {
+        parts.push(`Repo: ${node.repoName}`);
+    }
+    // Server name (optional)
+    if (node.serverName) {
+        parts.push(`Server: ${node.serverName}`);
+    }
+    // Full file path
+    parts.push(`Path: ${node.filePath}`);
+    // Export status
+    if (node.isExported !== undefined) {
+        parts.push(`Export: ${node.isExported}`);
+    }
+    // Description (truncated)
+    if (node.description) {
+        const maxLen = config.maxDescriptionLength ?? DEFAULT_EMBEDDING_CONFIG.maxDescriptionLength;
+        const truncated = truncateDescription(node.description, maxLen);
+        if (truncated) {
+            parts.push(truncated);
+        }
+    }
+    return parts.join('\n');
+};
+const generateCodeBodyText = (node, codeBody, config, prevTail) => {
+    const header = buildMetadataHeader(node, config);
+    const parts = [header];
+    if (prevTail) {
+        parts.push(`[preceding context]: ...${cleanContent(prevTail)}`);
+    }
+    parts.push('', cleanContent(codeBody));
+    return parts.join('\n');
+};
+const getCompactContainerContext = (cleanedContent, declarationOnly) => {
+    const source = declarationOnly || cleanedContent;
+    const nlIdx = source.indexOf('\n');
+    const firstLine = (nlIdx === -1 ? source : source.substring(0, nlIdx)).trim();
+    return firstLine ? `Container: ${firstLine}` : undefined;
+};
+const generateStructuralTypeText = (node, codeBody, config, chunkIndex, prevTail) => {
+    const header = buildMetadataHeader(node, config);
+    const parts = [header];
+    const isFirstChunk = chunkIndex === undefined || chunkIndex === 0;
+    const cleanedContent = cleanContent(node.content);
+    const declarationOnly = extractDeclarationOnly(cleanedContent);
+    const compactContainerContext = getCompactContainerContext(cleanedContent, declarationOnly);
+    if (compactContainerContext) {
+        parts.push(compactContainerContext);
+    }
+    if (prevTail) {
+        parts.push(`[preceding context]: ...${cleanContent(prevTail)}`);
+    }
+    if (isFirstChunk && node.methodNames?.length) {
+        parts.push(`Methods: ${node.methodNames.join(', ')}`);
+    }
+    if (isFirstChunk && node.fieldNames?.length) {
+        parts.push(`Properties: ${node.fieldNames.join(', ')}`);
+    }
+    if (isFirstChunk && declarationOnly) {
+        parts.push('', declarationOnly);
+    }
+    const cleanedChunk = cleanContent(codeBody);
+    if (cleanedChunk && cleanedChunk !== cleanedContent) {
+        parts.push('', cleanedChunk);
+    }
+    return parts.join('\n');
+};
+const DECL_START_RE = /^(?:(?:export|pub|data|abstract)\s+)*(?:type\s+\w+\s+struct|(?:class|struct|enum|interface)\s)/;
+/**
+ * Extract class/interface/struct declaration lines, skipping method bodies.
+ * - Brace-based languages: detects method signatures (lines with `(` and `{`)
+ *   and skips until depth returns to class body level.
+ * - Non-brace languages (Python/Ruby): returns empty string (patterns handle extraction).
+ */
+export const extractDeclarationOnly = (content) => {
+    const lines = content.split('\n');
+    const declLines = [];
+    let depth = 0;
+    let started = false;
+    let classDepth = 0;
+    let skipDepth = 0;
+    for (const [idx, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (!started) {
+            if (DECL_START_RE.test(trimmed)) {
+                // Non-brace language check: current line or next 3 lines must have `{`
+                const nextLines = lines.slice(idx + 1, idx + 4);
+                if (!trimmed.includes('{') && !nextLines.some((l) => l.includes('{'))) {
+                    return '';
+                }
+                started = true;
+                declLines.push(trimmed);
+                for (const ch of trimmed) {
+                    if (ch === '{')
+                        depth++;
+                    else if (ch === '}')
+                        depth--;
+                }
+                if (depth > 0)
+                    classDepth = depth;
+            }
+            continue;
+        }
+        // Always update depth (even when skipping)
+        const opens = (trimmed.match(/{/g) || []).length;
+        const closes = (trimmed.match(/}/g) || []).length;
+        const prevDepth = depth;
+        depth += opens - closes;
+        if (skipDepth > 0) {
+            if (depth <= classDepth) {
+                skipDepth = 0;
+                // Closing brace of class
+                if (depth <= 0) {
+                    declLines.push(trimmed);
+                    break;
+                }
+            }
+            continue;
+        }
+        // Detect method signature: line has both `(` and `{` and goes deeper than class body
+        const hasParens = trimmed.includes('(');
+        const hasOpenBrace = opens > 0;
+        if (hasParens && hasOpenBrace && prevDepth + opens > classDepth) {
+            if (opens === closes && trimmed.endsWith(';')) {
+                // Property with function/object initializer like `config = { timeout: 5000 };` — keep
+                declLines.push(trimmed);
+            }
+            // else: single-line or multi-line method — skip entirely
+            if (opens !== closes) {
+                skipDepth = classDepth;
+            }
+            continue;
+        }
+        declLines.push(trimmed);
+        if (depth <= 0 && declLines.length > 1)
+            break;
+    }
+    return declLines.join('\n').trim();
+};
+/**
+ * Generate embedding text for any embeddable node
+ * Dispatches to the appropriate generator based on node label
+ */
+export const generateEmbeddingText = (node, codeBody, config = {}, chunkIndex, prevTail) => {
+    if (isShortLabel(node.label)) {
+        const header = buildMetadataHeader(node, config);
+        const cleaned = cleanContent(node.content);
+        return `${header}\n\n${cleaned}`;
+    }
+    const chunkingRule = CHUNKING_RULES[node.label];
+    if (chunkingRule?.structuralTextMode === STRUCTURAL_TEXT_MODE_DECLARATION) {
+        return generateStructuralTypeText(node, codeBody, config, chunkIndex, prevTail);
+    }
+    return generateCodeBodyText(node, codeBody, config, prevTail);
+};
+/**
+ * Export truncation helper for testing
+ */
+export { truncateDescription };