@bndynet/ragbox 0.1.0

package/dist/src/folder-index/query.js

@@ -0,0 +1,597 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryStageError = void 0;
+exports.stripText = stripText;
+exports.buildNodeMap = buildNodeMap;
+exports.extractNodeTextFromMarkdown = extractNodeTextFromMarkdown;
+exports.resolveQueryIndexLocation = resolveQueryIndexLocation;
+exports.queryFolder = queryFolder;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+const llm_client_1 = require("./llm-client");
+const manifest_1 = require("./manifest");
+class QueryStageError extends Error {
+    stage;
+    cause;
+    constructor(stage, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        super(`Query failed during ${stage}: ${message}`);
+        this.name = "QueryStageError";
+        this.stage = stage;
+        this.cause = error;
+    }
+}
+exports.QueryStageError = QueryStageError;
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isVerbose() {
+    return process.env.RAGBOX_VERBOSE === "1" || process.env.RAGBOX_E2E_VERBOSE === "1";
+}
+function logVerbose(message) {
+    if (isVerbose()) {
+        console.error(`[ragbox] ${message}`);
+    }
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+function estimateTokenCount(value) {
+    const trimmed = value.trim();
+    return trimmed ? Math.ceil(trimmed.length / 4) : 0;
+}
+async function runQueryStage(stage, task) {
+    try {
+        return await task();
+    }
+    catch (error) {
+        if (error instanceof QueryStageError) {
+            throw error;
+        }
+        throw new QueryStageError(stage, error);
+    }
+}
+function addTraceFailure(trace, failure) {
+    trace?.failures.push(failure);
+}
+function stripText(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripText(item));
+    }
+    if (!isObject(value)) {
+        return value;
+    }
+    const stripped = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (key === "text") {
+            continue;
+        }
+        stripped[key] = stripText(nestedValue);
+    }
+    return stripped;
+}
+function getNodeId(value) {
+    for (const key of ["node_id", "nodeId", "id"]) {
+        const nodeId = value[key];
+        if (typeof nodeId === "string" && nodeId.length > 0) {
+            return nodeId;
+        }
+    }
+    return undefined;
+}
+function buildNodeMap(tree) {
+    const map = new Map();
+    const seen = new Set();
+    function visit(value) {
+        if (!value || seen.has(value)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            seen.add(value);
+            for (const item of value) {
+                visit(item);
+            }
+            return;
+        }
+        if (!isObject(value)) {
+            return;
+        }
+        seen.add(value);
+        const nodeId = getNodeId(value);
+        if (nodeId) {
+            map.set(nodeId, value);
+        }
+        for (const nestedValue of Object.values(value)) {
+            if (typeof nestedValue === "object" && nestedValue !== null) {
+                visit(nestedValue);
+            }
+        }
+    }
+    visit(tree);
+    return map;
+}
+function parseJsonObject(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const start = raw.indexOf("{");
+        const end = raw.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            return JSON.parse(raw.slice(start, end + 1));
+        }
+        throw new Error(`Expected JSON object from LLM, got: ${raw}`);
+    }
+}
+function lightweightRootTree(node) {
+    const base = {
+        node_id: node.node_id,
+        type: node.type,
+        title: node.title
+    };
+    if (node.type === "document") {
+        base.summary = node.summary;
+        base.path = node.path;
+    }
+    if (node.children?.length) {
+        base.children = node.children.map(lightweightRootTree);
+    }
+    return base;
+}
+function findDocumentNodes(rootTree) {
+    const documents = new Map();
+    function visit(node) {
+        if (node.type === "document") {
+            documents.set(node.node_id, node);
+        }
+        for (const child of node.children ?? []) {
+            visit(child);
+        }
+    }
+    visit(rootTree);
+    return documents;
+}
+function extractNodeText(node) {
+    const text = node.text;
+    return typeof text === "string" && text.trim() ? text.trim() : undefined;
+}
+function extractLexicalQueryTerms(question) {
+    const terms = new Set();
+    const codeLikeMatches = question.match(/[A-Za-z0-9_./:-]{6,}/g) ?? [];
+    for (const match of codeLikeMatches) {
+        terms.add(match.toLowerCase());
+    }
+    return [...terms];
+}
+function findLexicalNodeMatches(tree, question) {
+    const terms = extractLexicalQueryTerms(question);
+    const matches = new Set();
+    if (terms.length === 0) {
+        return matches;
+    }
+    const seen = new Set();
+    function visit(value) {
+        if (!value || seen.has(value)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            seen.add(value);
+            for (const item of value) {
+                visit(item);
+            }
+            return;
+        }
+        if (!isObject(value)) {
+            return;
+        }
+        seen.add(value);
+        const nodeId = getNodeId(value);
+        const text = extractNodeText(value)?.toLowerCase();
+        if (nodeId && text && terms.some((term) => text.includes(term))) {
+            matches.add(nodeId);
+        }
+        for (const nestedValue of Object.values(value)) {
+            if (typeof nestedValue === "object" && nestedValue !== null) {
+                visit(nestedValue);
+            }
+        }
+    }
+    visit(tree);
+    return matches;
+}
+function getLineNumber(value) {
+    for (const key of ["line_num", "lineNum", "line"]) {
+        const lineNumber = value[key];
+        if (typeof lineNumber === "number" && Number.isFinite(lineNumber) && lineNumber > 0) {
+            return Math.floor(lineNumber);
+        }
+        if (typeof lineNumber === "string") {
+            const parsed = Number.parseInt(lineNumber, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                return parsed;
+            }
+        }
+    }
+    return undefined;
+}
+function collectLineNumbers(tree) {
+    const lineNumbers = new Set();
+    const seen = new Set();
+    function visit(value) {
+        if (!value || seen.has(value)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            seen.add(value);
+            for (const item of value) {
+                visit(item);
+            }
+            return;
+        }
+        if (!isObject(value)) {
+            return;
+        }
+        seen.add(value);
+        const lineNumber = getLineNumber(value);
+        if (lineNumber) {
+            lineNumbers.add(lineNumber);
+        }
+        for (const nestedValue of Object.values(value)) {
+            if (typeof nestedValue === "object" && nestedValue !== null) {
+                visit(nestedValue);
+            }
+        }
+    }
+    visit(tree);
+    return [...lineNumbers].sort((left, right) => left - right);
+}
+function extractNodeTextFromMarkdown(node, tree, markdown) {
+    const startLine = getLineNumber(node);
+    if (!startLine) {
+        return undefined;
+    }
+    const lines = markdown.split(/\r?\n/);
+    const nextLine = collectLineNumbers(tree).find((lineNumber) => lineNumber > startLine) ?? lines.length + 1;
+    const text = lines.slice(startLine - 1, Math.max(startLine, nextLine - 1)).join("\n").trim();
+    return text || undefined;
+}
+async function readSourceMarkdown(rootDir, record) {
+    const candidates = [node_path_1.default.join(rootDir, record.path), record.absolutePath];
+    for (const candidate of candidates) {
+        try {
+            return await promises_1.default.readFile(candidate, "utf8");
+        }
+        catch {
+            // Try the next path. The manifest may have been moved with the index.
+        }
+    }
+    return undefined;
+}
+async function readJson(filePath) {
+    return JSON.parse(await promises_1.default.readFile(filePath, "utf8"));
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasQueryIndexFiles(outputDir) {
+    return (await pathExists(node_path_1.default.join(outputDir, manifest_1.MANIFEST_FILE))) && (await pathExists(node_path_1.default.join(outputDir, manifest_1.ROOT_TREE_FILE)));
+}
+async function readQueryIndexLocation(rootDir, outputDir) {
+    const manifestPath = node_path_1.default.join(outputDir, manifest_1.MANIFEST_FILE);
+    const rootTreePath = node_path_1.default.join(outputDir, manifest_1.ROOT_TREE_FILE);
+    const manifest = await readJson(manifestPath);
+    return {
+        rootDir: manifest.rootDir ? node_path_1.default.resolve(manifest.rootDir) : rootDir,
+        outputDir,
+        manifestPath,
+        rootTreePath
+    };
+}
+async function resolveQueryIndexLocation(target) {
+    const resolvedTarget = node_path_1.default.resolve(target);
+    const defaultOutputDir = node_path_1.default.join(resolvedTarget, manifest_1.PAGEINDEX_DIR);
+    if (await hasQueryIndexFiles(resolvedTarget)) {
+        return await readQueryIndexLocation(resolvedTarget, resolvedTarget);
+    }
+    if (await hasQueryIndexFiles(defaultOutputDir)) {
+        return await readQueryIndexLocation(resolvedTarget, defaultOutputDir);
+    }
+    throw new Error(`Expected a docs folder with ${manifest_1.PAGEINDEX_DIR}/${manifest_1.MANIFEST_FILE} and ${manifest_1.PAGEINDEX_DIR}/${manifest_1.ROOT_TREE_FILE}, or a ragbox output directory with ${manifest_1.MANIFEST_FILE} and ${manifest_1.ROOT_TREE_FILE}: ${target}`);
+}
+async function selectDocuments(question, rootTree, options) {
+    const prompt = `You are given a user question and a root documentation tree.
+Each document node has:
+- node_id
+- title
+- summary
+- path
+Select the documents most likely to contain the answer.
+Return only valid JSON:
+{
+  "documents": ["node_id_1", "node_id_2"]
+}
+User question:
+${question}
+Root tree:
+${JSON.stringify(lightweightRootTree(rootTree), null, 2)}`;
+    const response = await (0, llm_client_1.chatCompletion)([{ role: "user", content: prompt }], options);
+    const parsed = parseJsonObject(response);
+    return {
+        ids: Array.isArray(parsed.documents) ? parsed.documents.filter((id) => typeof id === "string") : [],
+        promptBytes: byteLength(prompt),
+        rawResponse: response,
+        responseBytes: byteLength(response)
+    };
+}
+async function selectPageIndexNodes(question, treeWithoutText, options) {
+    const prompt = `You are given a user question and a document tree.
+Each node has:
+- node_id
+- title
+- summary
+- child nodes
+Select the nodes most likely to contain the answer.
+Return only valid JSON:
+{
+  "nodes": ["node_id_1", "node_id_2"]
+}
+User question:
+${question}
+Document tree:
+${JSON.stringify(treeWithoutText, null, 2)}`;
+    const response = await (0, llm_client_1.chatCompletion)([{ role: "user", content: prompt }], options);
+    const parsed = parseJsonObject(response);
+    return {
+        ids: Array.isArray(parsed.nodes) ? parsed.nodes.filter((id) => typeof id === "string") : [],
+        promptBytes: byteLength(prompt),
+        rawResponse: response,
+        responseBytes: byteLength(response)
+    };
+}
+function elapsedSince(startedAt) {
+    return Date.now() - startedAt;
+}
+function documentSkipReason(documentNode, manifestRecord, indexPath) {
+    if (!documentNode) {
+        return "missing_root_tree_document";
+    }
+    if (!manifestRecord) {
+        return "missing_manifest_record";
+    }
+    if (!indexPath) {
+        return "missing_index_path";
+    }
+    if (manifestRecord.status !== "ready") {
+        return "document_not_ready";
+    }
+    return undefined;
+}
+async function queryFolder(target, question, options = {}) {
+    const totalStartedAt = Date.now();
+    const timings = {
+        resolve: 0,
+        selectDocuments: 0,
+        selectNodes: 0,
+        answer: 0,
+        total: 0
+    };
+    const warnings = [];
+    const selectedDocuments = [];
+    const selectedNodes = [];
+    const sources = [];
+    const config = (0, config_1.loadPageIndexConfig)(options);
+    const resolvedTarget = node_path_1.default.resolve(target);
+    const trace = options.trace
+        ? {
+            version: 1,
+            nodeSelections: [],
+            context: {
+                sourceCount: 0,
+                bytes: 0,
+                tokens: 0
+            },
+            failures: []
+        }
+        : undefined;
+    logVerbose(`query resolve target=${node_path_1.default.resolve(target)}`);
+    const resolveStartedAt = Date.now();
+    const location = await runQueryStage("resolve", async () => await resolveQueryIndexLocation(target));
+    logVerbose(`query index root=${location.rootDir} output=${location.outputDir ?? "(default)"}`);
+    const { manifest, rootTree } = await runQueryStage("read-index", async () => ({
+        manifest: await readJson(location.manifestPath),
+        rootTree: await readJson(location.rootTreePath)
+    }));
+    timings.resolve = elapsedSince(resolveStartedAt);
+    const documentNodes = findDocumentNodes(rootTree);
+    const manifestByDocId = new Map(manifest.documents.map((record) => [record.docId, record]));
+    logVerbose(`query select documents total=${manifest.documents.length}`);
+    const selectDocumentsStartedAt = Date.now();
+    const documentSelection = await runQueryStage("select-documents", async () => await selectDocuments(question, rootTree, options));
+    const selectedDocumentIds = documentSelection.ids;
+    if (trace) {
+        trace.documentSelection = {
+            promptBytes: documentSelection.promptBytes,
+            responseBytes: documentSelection.responseBytes,
+            rawResponse: documentSelection.rawResponse,
+            selectedDocumentIds
+        };
+    }
+    timings.selectDocuments = elapsedSince(selectDocumentsStartedAt);
+    logVerbose(`query selected documents count=${selectedDocumentIds.length} ids=${selectedDocumentIds.join(",")}`);
+    for (const docId of selectedDocumentIds) {
+        const documentNode = documentNodes.get(docId);
+        const manifestRecord = manifestByDocId.get(docId);
+        const indexPath = documentNode?.index_path ?? manifestRecord?.indexPath;
+        const available = Boolean(documentNode && manifestRecord && indexPath && manifestRecord.status === "ready");
+        const skipReason = documentSkipReason(documentNode, manifestRecord, indexPath);
+        const selectedDocument = {
+            docId,
+            available,
+            path: manifestRecord?.path ?? documentNode?.path,
+            title: manifestRecord?.title ?? documentNode?.title,
+            status: manifestRecord?.status,
+            indexPath,
+            selectionReason: "selected_by_document_planner"
+        };
+        if (skipReason) {
+            selectedDocument.skipReason = skipReason;
+        }
+        selectedDocuments.push(selectedDocument);
+        if (!available || !documentNode || !manifestRecord || !indexPath) {
+            logVerbose(`query skip unavailable document id=${docId}`);
+            warnings.push(`Selected document is unavailable: ${docId}`);
+            addTraceFailure(trace, {
+                stage: "read-document-index",
+                code: skipReason ?? "document_unavailable",
+                message: `Selected document is unavailable: ${docId}`,
+                docId,
+                path: manifestRecord?.path ?? documentNode?.path
+            });
+            continue;
+        }
+        logVerbose(`query read pageindex path=${manifestRecord.path}`);
+        const pageIndexJson = await runQueryStage("read-document-index", async () => await readJson((0, manifest_1.resolveDocumentIndexPath)(location.rootDir, indexPath, location.outputDir)));
+        logVerbose(`query select nodes path=${manifestRecord.path}`);
+        const selectNodesStartedAt = Date.now();
+        const treeWithoutText = stripText(pageIndexJson);
+        const nodeSelection = await runQueryStage("select-nodes", async () => await selectPageIndexNodes(question, treeWithoutText, options));
+        const lexicalNodeIds = findLexicalNodeMatches(pageIndexJson, question);
+        const selectedNodeIds = [...new Set([...nodeSelection.ids, ...lexicalNodeIds])];
+        trace?.nodeSelections.push({
+            docId,
+            path: manifestRecord.path,
+            promptBytes: nodeSelection.promptBytes,
+            responseBytes: nodeSelection.responseBytes,
+            rawResponse: nodeSelection.rawResponse,
+            selectedNodeIds
+        });
+        timings.selectNodes += elapsedSince(selectNodesStartedAt);
+        logVerbose(`query selected nodes path=${manifestRecord.path} count=${selectedNodeIds.length} ids=${selectedNodeIds.join(",")}`);
+        const nodeMap = buildNodeMap(pageIndexJson);
+        let sourceMarkdown;
+        for (const nodeId of selectedNodeIds) {
+            const node = nodeMap.get(nodeId);
+            const reference = `${manifestRecord.path}#${nodeId}`;
+            const selectedNode = {
+                docId,
+                path: manifestRecord.path,
+                nodeId,
+                found: Boolean(node),
+                hasText: false,
+                reference,
+                selectionReason: nodeSelection.ids.includes(nodeId) ? "selected_by_node_planner" : "matched_query_text"
+            };
+            if (!node) {
+                selectedNode.skipReason = "node_not_found";
+                selectedNodes.push(selectedNode);
+                warnings.push(`Selected node was not found: ${reference}`);
+                addTraceFailure(trace, {
+                    stage: "extract-context",
+                    code: "node_not_found",
+                    message: `Selected node was not found: ${reference}`,
+                    docId,
+                    nodeId,
+                    path: manifestRecord.path,
+                    reference
+                });
+                continue;
+            }
+            let text = extractNodeText(node);
+            if (!text) {
+                sourceMarkdown ??= await readSourceMarkdown(location.rootDir, manifestRecord);
+                text = sourceMarkdown ? extractNodeTextFromMarkdown(node, pageIndexJson, sourceMarkdown) : undefined;
+                if (text) {
+                    logVerbose(`query fallback markdown text path=${manifestRecord.path} node=${nodeId}`);
+                }
+            }
+            if (!text) {
+                selectedNode.skipReason = "missing_text";
+                selectedNodes.push(selectedNode);
+                warnings.push(`Selected node has no extractable text: ${reference}`);
+                addTraceFailure(trace, {
+                    stage: "extract-context",
+                    code: "missing_text",
+                    message: `Selected node has no extractable text: ${reference}`,
+                    docId,
+                    nodeId,
+                    path: manifestRecord.path,
+                    reference
+                });
+                continue;
+            }
+            selectedNode.hasText = true;
+            selectedNode.textBytes = byteLength(text);
+            selectedNodes.push(selectedNode);
+            sources.push({
+                path: manifestRecord.path,
+                nodeId,
+                reference,
+                text
+            });
+        }
+    }
+    if (sources.length === 0) {
+        warnings.push("No relevant context was extracted from the selected index nodes.");
+        addTraceFailure(trace, {
+            stage: "extract-context",
+            code: "empty_context",
+            message: "No relevant context was extracted from the selected index nodes."
+        });
+    }
+    const context = sources.length > 0 ? sources.map((source) => `Source: ${source.reference}\n${source.text}`).join("\n\n---\n\n") : "(no relevant context found)";
+    const contextBytes = byteLength(context);
+    const contextTokens = estimateTokenCount(context);
+    if (trace) {
+        trace.context = {
+            sourceCount: sources.length,
+            bytes: contextBytes,
+            tokens: contextTokens
+        };
+    }
+    logVerbose(`query final answer contextParts=${sources.length}`);
+    const finalPrompt = `Answer the user question using only the provided context.
+If the context is insufficient, say that you could not find enough information in the available documentation.
+Do not expose implementation details about how the documentation was found or prepared.
+Include source references using the file path and node_id when possible.
+User question:
+${question}
+Context:
+${context}`;
+    const answerStartedAt = Date.now();
+    const answer = await runQueryStage("answer", async () => await (0, llm_client_1.chatCompletion)([{ role: "user", content: finalPrompt }], options));
+    if (trace) {
+        trace.answer = {
+            promptBytes: byteLength(finalPrompt),
+            responseBytes: byteLength(answer)
+        };
+    }
+    timings.answer = elapsedSince(answerStartedAt);
+    timings.total = elapsedSince(totalStartedAt);
+    return {
+        version: 1,
+        target: resolvedTarget,
+        rootDir: location.rootDir,
+        outputDir: location.outputDir ?? node_path_1.default.join(location.rootDir, manifest_1.PAGEINDEX_DIR),
+        question,
+        model: config.model,
+        answer,
+        contextBytes,
+        contextTokens,
+        selectedDocuments,
+        selectedNodes,
+        sources,
+        warnings,
+        timingsMs: timings,
+        ...(trace ? { trace } : {})
+    };
+}

package/dist/src/folder-index/queue.d.ts

@@ -0,0 +1 @@
+export declare function runWithConcurrency<T, R>(items: T[], concurrency: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/src/folder-index/queue.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithConcurrency = runWithConcurrency;
+async function runWithConcurrency(items, concurrency, worker) {
+    const limit = Math.max(1, Math.floor(concurrency));
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function runWorker() {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, items.length) }, () => runWorker());
+    await Promise.all(workers);
+    return results;
+}

package/dist/src/folder-index/root-tree.d.ts

@@ -0,0 +1,3 @@
+import { Manifest, RootTreeNode } from "./types";
+export declare function generateRootTree(manifest: Manifest): RootTreeNode;
+export declare function writeRootTree(rootDir: string, rootTree: RootTreeNode, outputDir?: string): Promise<void>;

package/dist/src/folder-index/root-tree.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRootTree = generateRootTree;
+exports.writeRootTree = writeRootTree;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const manifest_1 = require("./manifest");
+function createDirectoryNodeId(relativePath) {
+    const digest = (0, node_crypto_1.createHash)("sha1").update(relativePath || ".").digest("hex");
+    return `dir:${digest}`;
+}
+function sortTree(node) {
+    if (!node.children) {
+        return;
+    }
+    node.children.sort((left, right) => {
+        if (left.type !== right.type) {
+            if (left.type === "directory") {
+                return -1;
+            }
+            if (right.type === "directory") {
+                return 1;
+            }
+        }
+        return left.title.localeCompare(right.title) || (left.path ?? "").localeCompare(right.path ?? "");
+    });
+    for (const child of node.children) {
+        sortTree(child);
+    }
+}
+function generateRootTree(manifest) {
+    const rootTitle = node_path_1.default.basename(manifest.rootDir) || manifest.rootDir;
+    const root = {
+        node_id: "root",
+        type: "root",
+        title: rootTitle,
+        children: []
+    };
+    const directories = new Map([["", root]]);
+    for (const record of manifest.documents) {
+        if (record.status !== "ready") {
+            continue;
+        }
+        const parts = record.path.split("/");
+        let parent = root;
+        let currentRelativeDir = "";
+        for (const part of parts.slice(0, -1)) {
+            currentRelativeDir = currentRelativeDir ? `${currentRelativeDir}/${part}` : part;
+            let directoryNode = directories.get(currentRelativeDir);
+            if (!directoryNode) {
+                directoryNode = {
+                    node_id: createDirectoryNodeId(currentRelativeDir),
+                    type: "directory",
+                    title: part,
+                    path: currentRelativeDir,
+                    children: []
+                };
+                directories.set(currentRelativeDir, directoryNode);
+                parent.children ??= [];
+                parent.children.push(directoryNode);
+            }
+            parent = directoryNode;
+        }
+        parent.children ??= [];
+        parent.children.push({
+            node_id: record.docId,
+            type: "document",
+            title: record.title,
+            summary: record.summary,
+            path: record.path,
+            index_path: record.indexPath
+        });
+    }
+    sortTree(root);
+    return root;
+}
+async function writeRootTree(rootDir, rootTree, outputDir) {
+    await (0, manifest_1.atomicWriteJson)((0, manifest_1.getPageIndexPath)(rootDir, manifest_1.ROOT_TREE_FILE, outputDir), rootTree);
+}