svharness 0.8.0

package/dist/wiki/repowikiMarkdownPost.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markdownRelLinkToRepoFile = markdownRelLinkToRepoFile;
+exports.splitSourcePathAndLineRef = splitSourcePathAndLineRef;
+exports.markdownLineFragmentFromSuffix = markdownLineFragmentFromSuffix;
+exports.linkifySourcesLinesInMarkdown = linkifySourcesLinesInMarkdown;
+const path = __importStar(require("path"));
+/**
+ * POSIX-style relative `href` from a generated wiki `.md` file to a repo file.
+ * Markdown viewers (VS Code preview, GitHub, mkdocs) resolve these against the
+ * source `.md` URI; append `markdownLineFragmentFromSuffix` so clicks jump to a line range.
+ */
+function markdownRelLinkToRepoFile(mdAbsPath, repoRootFs, fileRelPosix) {
+    const norm = fileRelPosix.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+    if (!norm)
+        return "";
+    const targetAbs = path.resolve(repoRootFs, norm);
+    const fromDir = path.dirname(mdAbsPath);
+    let rel = path.relative(fromDir, targetAbs);
+    rel = rel.split(/[/\\]/g).join("/");
+    return rel;
+}
+/** `path:line`, `path:10-20` — uses last `:` when the tail is numeric. */
+function splitSourcePathAndLineRef(token) {
+    const t = token.trim().replace(/^`([^`]+)`$/, "$1").trim();
+    if (!t)
+        return { filePath: "", lineSuffix: "" };
+    const lastColon = t.lastIndexOf(":");
+    if (lastColon <= 0)
+        return { filePath: t, lineSuffix: "" };
+    const tail = t.slice(lastColon + 1);
+    if (/^\d+(?:-\d+)?$/.test(tail)) {
+        return { filePath: t.slice(0, lastColon), lineSuffix: `:${tail}` };
+    }
+    return { filePath: t, lineSuffix: "" };
+}
+/**
+ * `#L<n>` / `#L<a>-L<b>` line-range fragment. GitHub, GitLab and the VS Code
+ * built-in Markdown preview all honour this format.
+ */
+function markdownLineFragmentFromSuffix(lineSuffix) {
+    if (!lineSuffix.startsWith(":"))
+        return "";
+    const inner = lineSuffix.slice(1).trim();
+    const range = /^(\d+)-(\d+)$/.exec(inner);
+    if (range) {
+        const a = range[1];
+        const b = range[2];
+        return `#L${a}-L${b}`;
+    }
+    const one = /^(\d+)$/.exec(inner);
+    return one ? `#L${one[1]}` : "";
+}
+/**
+ * Turns `Sources: a/b.kt:1-2, README.md` into markdown links with paths relative to the wiki page file.
+ */
+function linkifySourcesLinesInMarkdown(md, mdAbsPath, repoRootFs) {
+    const lines = md.split(/\r?\n/);
+    /** Optional list marker; `Sources:`, `**Sources:**`, or closing-bold-before-colon `**Sources**:`. */
+    const lineRe = /^(\s*(?:[-*]\s+)?(?:\*\*Sources:\*\*|\*\*Sources\*\*:|Sources:)\s*)(.+)$/i;
+    const out = lines.map((line) => {
+        const m = line.match(lineRe);
+        if (!m)
+            return line;
+        const prefix = m[1];
+        const rest = m[2];
+        const parts = rest
+            .split(",")
+            .map((p) => p.trim())
+            .filter(Boolean);
+        const linked = parts
+            .map((part) => {
+            const { filePath, lineSuffix } = splitSourcePathAndLineRef(part);
+            if (!filePath)
+                return part;
+            let href = markdownRelLinkToRepoFile(mdAbsPath, repoRootFs, filePath);
+            if (!href)
+                return part;
+            const frag = markdownLineFragmentFromSuffix(lineSuffix);
+            if (frag)
+                href = `${href}${frag}`;
+            const base = path.posix.basename(filePath.replace(/\\/g, "/"));
+            const label = `${base}${lineSuffix}`;
+            return `[${label}](${href})`;
+        })
+            .join(", ");
+        return `${prefix}${linked}`;
+    });
+    return out.join("\n");
+}

package/dist/wiki/repowikiMetadataContent.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8TextToContentBase64 = utf8TextToContentBase64;
+exports.collectContentBase64ByLang = collectContentBase64ByLang;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+/** Standard base64 of UTF-8 bytes (portable embedding of Markdown in JSON). */
+function utf8TextToContentBase64(text) {
+    return Buffer.from(text, "utf8").toString("base64");
+}
+/**
+ * For each language folder, read generated Markdown at `wikiBase/<lang>/<rel>` and
+ * return page-id → base64 maps (same page ids as `metadata.files`).
+ */
+async function collectContentBase64ByLang(options) {
+    const out = {};
+    for (const folder of options.langFolders) {
+        const byPage = {};
+        for (const pageId of options.pageIds) {
+            const rel = options.filesRelByPageId.get(pageId);
+            if (!rel) {
+                throw new Error(`[repowiki] Missing file mapping for page ${pageId}`);
+            }
+            const abs = path.join(options.wikiBase, folder, ...rel.split("/").filter(Boolean));
+            const text = await fs.readFile(abs, "utf8");
+            byPage[pageId] = utf8TextToContentBase64(text);
+        }
+        out[folder] = byPage;
+    }
+    return out;
+}

package/dist/wiki/repowikiMetadataJson.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPOWIKI_METADATA_SCHEMA_VERSION = exports.REPOWIKI_METADATA_SCHEMA_ID = void 0;
+/**
+ * Shape of `<wikiRoot>/metadata.json` produced by `runRepowikiIndex`.
+ *
+ * `version` and `metadataSchemaVersion` are the same integer; bump both only on
+ * incompatible JSON changes. Markdown bodies appear only under `contentBase64ByLang`
+ * (standard base64 of UTF‑8) when embedding is enabled — there is no parallel plain-text
+ * `content` field to avoid duplicating large strings. Paths in `files` are relative to
+ * each folder named in `langFolders` (on disk: `<wikiBaseFs>/<lang>/<files[id]>`).
+ */
+exports.REPOWIKI_METADATA_SCHEMA_ID = "deepwiki-open.repowiki";
+/** Bumped with breaking changes to this file’s top-level keys or semantics. */
+exports.REPOWIKI_METADATA_SCHEMA_VERSION = 2;

package/dist/wiki/repowikiScanner.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTextFileBounded = readTextFileBounded;
+exports.collectRepoFileList = collectRepoFileList;
+exports.tryReadFirstReadme = tryReadFirstReadme;
+exports.bundleSourceContext = bundleSourceContext;
+exports.summarizeTreeLines = summarizeTreeLines;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const SKIP_DIR_NAMES = new Set([
+    ".git",
+    "node_modules",
+    ".venv",
+    ".venv-smoke",
+    "__pycache__",
+    "dist",
+    "out",
+    "build",
+    ".next",
+    "coverage",
+    ".turbo",
+    ".cache",
+    "target",
+    ".idea",
+]);
+const SKIP_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".7z",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".eot",
+    ".mp4",
+    ".mp3",
+    ".wav",
+]);
+const TEXT_MAX_FILE = 80_000;
+const LIST_FILES_MAX_PARTS = 220;
+async function readTextFileBounded(absPath, maxBytes = TEXT_MAX_FILE) {
+    try {
+        const buf = await fs.readFile(absPath);
+        if (buf.length > maxBytes) {
+            const slice = buf.subarray(0, maxBytes).toString("utf8");
+            return `${slice}\n\n…truncated (${buf.length} bytes total)`;
+        }
+        return buf.toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function walkRelFiles(rootFs, relParts, sink) {
+    if (sink.length >= LIST_FILES_MAX_PARTS)
+        return;
+    const dirAbs = path.join(rootFs, ...relParts);
+    let entries;
+    try {
+        entries = await fs.readdir(dirAbs, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        if (sink.length >= LIST_FILES_MAX_PARTS)
+            break;
+        if (SKIP_DIR_NAMES.has(ent.name))
+            continue;
+        if (ent.name.startsWith(".") && ent.name !== ".github")
+            continue;
+        const rel = [...relParts, ent.name];
+        if (ent.isDirectory()) {
+            await walkRelFiles(rootFs, rel, sink);
+            continue;
+        }
+        const ext = path.extname(ent.name).toLowerCase();
+        if (SKIP_EXTENSIONS.has(ext))
+            continue;
+        sink.push(rel.join("/"));
+    }
+}
+/** Flat list of relative paths for LLM prompt (POSIX-ish slashes). */
+async function collectRepoFileList(repoRootFs) {
+    const acc = [];
+    await walkRelFiles(repoRootFs, [], acc);
+    return acc;
+}
+async function tryReadFirstReadme(repoRootFs) {
+    const names = ["README.md", "README.MD", "readme.md", "Readme.md", "README.rst"];
+    for (const n of names) {
+        const t = await readTextFileBounded(path.join(repoRootFs, n), 120_000);
+        if (t?.trim())
+            return t;
+    }
+    return "";
+}
+async function bundleSourceContext(repoRootFs, relativePaths, perFileBudget) {
+    const uniq = [...new Set(relativePaths)].slice(0, 16);
+    const chunks = [];
+    for (const rp of uniq) {
+        const safe = rp.replace(/^[/\\]+/, "");
+        const abs = path.join(repoRootFs, safe);
+        if (!abs.startsWith(path.resolve(repoRootFs)))
+            continue;
+        const body = await readTextFileBounded(abs, perFileBudget);
+        if (!body?.trim())
+            continue;
+        chunks.push(`<file path="${safe.replace(/"/g, "")}">\n${body}\n</file>`);
+    }
+    return chunks.join("\n\n");
+}
+function summarizeTreeLines(paths, maxLines = 200) {
+    const sorted = [...paths].sort();
+    return sorted.slice(0, maxLines).join("\n");
+}

package/dist/wiki/repowikiStructureNav.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractWikiOutlineTitle = extractWikiOutlineTitle;
+exports.parseSectionGroups = parseSectionGroups;
+exports.loadWikiNavigationFromMarkdownDir = loadWikiNavigationFromMarkdownDir;
+exports.loadWikiNavigationFromDiskOnly = loadWikiNavigationFromDiskOnly;
+exports.loadWikiNavigation = loadWikiNavigation;
+const fsp = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const wikiStructureXml_1 = require("./wikiStructureXml");
+const repowikiConfig_1 = require("./repowikiConfig");
+function stripTags(s) {
+    return s.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function xmlPlainText(s) {
+    return (0, wikiStructureXml_1.decodeXmlEntities)(stripTags(s));
+}
+/** First `<title>` after xml start — outline title. */
+function extractWikiOutlineTitle(xml) {
+    const inner = xml.replace(/^\uFEFF/, "");
+    const m = inner.match(/<title>([\s\S]*?)<\/title>/i);
+    return m ? xmlPlainText(m[1]).slice(0, 200) : "";
+}
+function parseSectionBlocksFromInner(inner) {
+    const blocks = [];
+    let pos = 0;
+    while (pos < inner.length) {
+        const m = inner.slice(pos).match(/<section\b([^>]*)>/i);
+        if (!m || m.index === undefined)
+            break;
+        const absStart = pos + m.index;
+        const attrs = m[1] ?? "";
+        const openTagLen = m[0].length;
+        const contentStart = absStart + openTagLen;
+        let idx = contentStart;
+        let depth = 1;
+        while (idx < inner.length && depth > 0) {
+            const tail = inner.slice(idx);
+            const mo = tail.match(/<section\b[^>]*>/i);
+            const mc = tail.match(/<\/section>/i);
+            const io = mo?.index ?? -1;
+            const ic = mc?.index ?? -1;
+            if (ic === -1) {
+                blocks.push({ attr: attrs, body: inner.slice(contentStart) });
+                return blocks;
+            }
+            if (io !== -1 && io < ic) {
+                depth++;
+                idx += io + mo[0].length;
+            }
+            else {
+                depth--;
+                if (depth === 0) {
+                    blocks.push({ attr: attrs, body: inner.slice(contentStart, idx + ic) });
+                    pos = idx + ic + mc[0].length;
+                    break;
+                }
+                idx += ic + mc[0].length;
+            }
+        }
+        if (depth > 0) {
+            return blocks;
+        }
+    }
+    return blocks;
+}
+function parseSectionGroups(structureXml) {
+    const body = structureXml.replace(/^\uFEFF/, "");
+    const inner = (0, wikiStructureXml_1.extractSectionsInnerXml)(body);
+    if (!inner.trim())
+        return [];
+    const out = [];
+    const blocks = parseSectionBlocksFromInner(inner);
+    for (let i = 0; i < blocks.length; i++) {
+        const { attr, body: block } = blocks[i];
+        const idM = attr.match(/\bid\s*=\s*"([^"]*)"/i);
+        const sid = (0, wikiStructureXml_1.sanitizeWikiOutlineId)(idM?.[1]?.trim() || `section-${out.length}`);
+        const titleM = block.match(/<title>([\s\S]*?)<\/title>/i);
+        const title = titleM ? xmlPlainText(titleM[1]) : sid;
+        const pageIds = [];
+        const refRe = /<page_ref>([\s\S]*?)<\/page_ref>/gi;
+        let rm;
+        while ((rm = refRe.exec(block)) !== null) {
+            const pid = (0, wikiStructureXml_1.sanitizeWikiOutlineId)(xmlPlainText(rm[1]));
+            if (pid)
+                pageIds.push(pid);
+        }
+        out.push({ id: sid, title, pageIds });
+    }
+    return out;
+}
+async function safeReadUtf8(abs) {
+    try {
+        return await fsp.readFile(abs, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function humanizeMdFilenameStem(stem) {
+    const s = stem.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim();
+    return s || stem;
+}
+async function collectMarkdownFilesRecursive(dirAbs) {
+    const out = [];
+    let ents;
+    try {
+        ents = await fsp.readdir(dirAbs, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of ents) {
+        const name = e.name;
+        const abs = path.join(dirAbs, name);
+        if (e.isDirectory()) {
+            out.push(...(await collectMarkdownFilesRecursive(abs)));
+        }
+        else if (e.isFile() && name.toLowerCase().endsWith(".md")) {
+            out.push(abs);
+        }
+    }
+    return out;
+}
+function relPosixFromLangDir(langDirAbs, fileAbs) {
+    return path.relative(langDirAbs, fileAbs).replace(/\\/g, "/");
+}
+async function loadWikiNavigationFromMarkdownDir(langDirAbs, wikiTitle) {
+    const absPaths = await collectMarkdownFilesRecursive(langDirAbs);
+    const files = absPaths.map((abs) => ({
+        abs,
+        relPosix: relPosixFromLangDir(langDirAbs, abs),
+    }));
+    if (!files.length) {
+        return { wikiTitle, groups: [] };
+    }
+    files.sort((a, b) => a.relPosix.localeCompare(b.relPosix));
+    const rootMd = files.filter((f) => !f.relPosix.includes("/"));
+    const nestedMd = files.filter((f) => f.relPosix.includes("/"));
+    if (rootMd.length === files.length) {
+        const leaves = rootMd.map((f) => {
+            const stem = f.relPosix.slice(0, -3);
+            return {
+                pageId: stem,
+                title: humanizeMdFilenameStem(stem),
+                absPath: f.abs,
+            };
+        });
+        return { wikiTitle, groups: [{ id: "root", title: "文档", pages: leaves }] };
+    }
+    const navGroups = [];
+    if (rootMd.length) {
+        const leaves = rootMd.map((f) => {
+            const stem = f.relPosix.slice(0, -3);
+            return {
+                pageId: stem,
+                title: humanizeMdFilenameStem(stem),
+                absPath: f.abs,
+            };
+        });
+        navGroups.push({ id: "root", title: "文档", pages: leaves });
+    }
+    const byFirst = new Map();
+    for (const f of nestedMd) {
+        const first = f.relPosix.split("/")[0];
+        const arr = byFirst.get(first) ?? [];
+        arr.push(f);
+        byFirst.set(first, arr);
+    }
+    for (const [first, groupFiles] of [...byFirst.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        const leaves = groupFiles.map((f) => {
+            const rest = f.relPosix.slice(first.length + 1);
+            const stemNoMd = rest.endsWith(".md") ? rest.slice(0, -3) : rest;
+            const pageId = f.relPosix.replace(/\.md$/i, "").replace(/\//g, "__");
+            return {
+                pageId,
+                title: humanizeMdFilenameStem(stemNoMd) || humanizeMdFilenameStem(first),
+                absPath: f.abs,
+            };
+        });
+        leaves.sort((a, b) => a.title.localeCompare(b.title));
+        navGroups.push({
+            id: `dir-${first}`,
+            title: humanizeMdFilenameStem(first) || first,
+            pages: leaves,
+        });
+    }
+    return { wikiTitle, groups: navGroups };
+}
+async function loadWikiNavigationFromDiskOnly(wikiRootAbs, langFolder) {
+    const structureRaw = await safeReadUtf8(path.join(wikiRootAbs, "structure.xml"));
+    const wikiTitle = extractWikiOutlineTitle(structureRaw) || "Repo Wiki";
+    const langDir = path.join(wikiRootAbs, langFolder);
+    return loadWikiNavigationFromMarkdownDir(langDir, wikiTitle);
+}
+async function loadWikiNavigation(wikiRootAbs, langFolder) {
+    const structureRaw = await safeReadUtf8(path.join(wikiRootAbs, "structure.xml"));
+    const langDir = path.join(wikiRootAbs, langFolder);
+    const meta = await (0, repowikiConfig_1.loadRepowikiMetadata)(wikiRootAbs);
+    const pageFiles = meta?.files;
+    let wikiTitle = extractWikiOutlineTitle(structureRaw) || "Repo Wiki";
+    const pages = (0, wikiStructureXml_1.parseWikiPages)(structureRaw);
+    if (!structureRaw.trim() || pages.length === 0) {
+        return loadWikiNavigationFromMarkdownDir(langDir, wikiTitle);
+    }
+    const pmap = new Map(pages.map((p) => [p.id, p]));
+    const buildLeaf = (pid) => {
+        const p = pmap.get(pid);
+        if (!p)
+            return undefined;
+        const rel = pageFiles?.[pid] ?? `${(0, wikiStructureXml_1.slugifyFileStem)(p.id)}.md`;
+        const relNorm = rel.replace(/\\/g, "/");
+        const segments = relNorm.split("/").filter(Boolean);
+        return {
+            pageId: p.id,
+            title: p.title || p.id,
+            absPath: path.join(langDir, ...segments),
+        };
+    };
+    const sectionGroups = parseSectionGroups(structureRaw);
+    if (sectionGroups.length === 0) {
+        const leaves = pages.map((pg) => buildLeaf(pg.id)).filter(Boolean);
+        return { wikiTitle, groups: [{ id: "root", title: "文档", pages: leaves }] };
+    }
+    const used = new Set();
+    const navGroups = [];
+    for (const g of sectionGroups) {
+        const leaves = [];
+        for (const pid of g.pageIds) {
+            const leaf = buildLeaf(pid);
+            if (leaf) {
+                leaves.push(leaf);
+                used.add(pid);
+            }
+        }
+        if (leaves.length) {
+            navGroups.push({ id: g.id, title: g.title, pages: leaves });
+        }
+    }
+    const orphans = pages.filter((p) => !used.has(p.id));
+    if (orphans.length > 0) {
+        navGroups.push({
+            id: "other",
+            title: "其他",
+            pages: orphans.map((pg) => buildLeaf(pg.id)).filter(Boolean),
+        });
+    }
+    if (navGroups.length === 0 && pages.length > 0) {
+        const leaves = pages.map((pg) => buildLeaf(pg.id)).filter(Boolean);
+        return { wikiTitle, groups: [{ id: "root", title: "文档", pages: leaves }] };
+    }
+    return { wikiTitle, groups: navGroups };
+}