diffwiki-core 0.6.0 → 0.6.1-rc.202607250144.696649b

package/dist/index.cjs

@@ -577,6 +577,7 @@ __export(index_exports, {
   addTags: () => addTags,
   buildArticleTree: () => buildArticleTree,
   buildCollections: () => buildCollections,
+  buildLinkGraph: () => buildLinkGraph,
   buildNavTree: () => buildNavTree,
   buildSearchIndex: () => buildSearchIndex,
   collectionDir: () => collectionDir,
@@ -591,6 +592,7 @@ __export(index_exports, {
   emitPluginEvent: () => emitPluginEvent,
   ensureGitRepo: () => ensureGitRepo,
   ensurePluginRoot: () => ensurePluginRoot,
+  fileTimestamps: () => fileTimestamps,
   findCollection: () => findCollection,
   findCollectionById: () => findCollectionById,
   findEnabledPlugin: () => findEnabledPlugin,
@@ -600,6 +602,7 @@ __export(index_exports, {
   gitToplevel: () => gitToplevel,
   initRepoWiki: () => initRepoWiki,
   installPlugin: () => installPlugin,
+  invalidateLinkGraph: () => invalidateLinkGraph,
   isLinkedWorktree: () => isLinkedWorktree,
   listArticleTree: () => listArticleTree,
   listAvailablePlugins: () => listAvailablePlugins,
@@ -608,6 +611,7 @@ __export(index_exports, {
   listPlugins: () => listPlugins,
   listSearchModes: () => listSearchModes,
   loadSearchProvider: () => loadSearchProvider,
+  localGraph: () => localGraph,
   nativeSearch: () => nativeSearch,
   parseAddTarget: () => parseAddTarget,
   parseArticle: () => parseArticle,
@@ -755,8 +759,6 @@ function parseArticle(raw) {
 }
 function serializeArticle(article) {
   const front = { title: article.title, tags: article.tags };
-  if (article.created) front.created = article.created;
-  if (article.updated) front.updated = article.updated;
   return import_gray_matter.default.stringify(article.body, front, MATTER_OPTS);
 }
 
@@ -816,11 +818,10 @@ async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
   const filePath = import_node_path3.default.join(dir, `${slugify(title)}.md`);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
   const body = opts.body ?? `# ${title}
 `;
   await import_promises5.default.mkdir(dir, { recursive: true });
-  await import_promises5.default.writeFile(filePath, serializeArticle({ title, tags: opts.tags, created: now, updated: now, body }), "utf8");
+  await import_promises5.default.writeFile(filePath, serializeArticle({ title, tags: opts.tags, body }), "utf8");
   void fireHook2("article-created", name, import_node_path3.default.relative(dir, filePath));
   return { title, tags: opts.tags, path: filePath, collection: name };
 }
@@ -838,17 +839,7 @@ async function loadArticle(target) {
 async function updateArticleBody(target, body) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  await import_promises5.default.writeFile(
-    filePath,
-    serializeArticle({
-      title: parsed.title,
-      tags: parsed.tags,
-      created: parsed.created,
-      updated: (/* @__PURE__ */ new Date()).toISOString(),
-      body
-    }),
-    "utf8"
-  );
+  await import_promises5.default.writeFile(filePath, serializeArticle({ title: parsed.title, tags: parsed.tags, body }), "utf8");
   void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
@@ -856,17 +847,7 @@ async function mutateTags(target, fn) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
   const tags = fn(parsed.tags);
-  await import_promises5.default.writeFile(
-    filePath,
-    serializeArticle({
-      title: parsed.title,
-      tags,
-      created: parsed.created,
-      updated: (/* @__PURE__ */ new Date()).toISOString(),
-      body: parsed.body
-    }),
-    "utf8"
-  );
+  await import_promises5.default.writeFile(filePath, serializeArticle({ title: parsed.title, tags, body: parsed.body }), "utf8");
   void fireHook2("article-updated", collection, import_node_path3.default.relative(dir, filePath));
   return { title: parsed.title, tags, path: filePath, collection };
 }
@@ -888,7 +869,7 @@ async function removeArticle(target) {
 }
 
 // src/repo.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_promises7 = __toESM(require("fs/promises"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
 var import_node_child_process3 = require("child_process");
 var import_node_util2 = require("util");
@@ -897,6 +878,7 @@ init_collections();
 init_registry();
 
 // src/git.ts
+var import_promises6 = __toESM(require("fs/promises"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
@@ -959,6 +941,35 @@ async function ensureGitRepo(cwd) {
   if (!after) throw new Error("git init did not produce a repository");
   return after;
 }
+function isEpochish(d) {
+  return !Number.isFinite(d.getTime()) || d.getTime() <= 0;
+}
+var timestampCache = /* @__PURE__ */ new Map();
+async function fileTimestamps(absPath) {
+  const cached2 = timestampCache.get(absPath);
+  if (cached2) return cached2;
+  const dir = import_node_path4.default.dirname(absPath);
+  const base = import_node_path4.default.basename(absPath);
+  const [addLog, lastLog] = await Promise.all([
+    git(dir, ["log", "--follow", "--diff-filter=A", "--format=%aI", "--", base]),
+    git(dir, ["log", "-1", "--format=%aI", "--", base])
+  ]);
+  const gitCreated = addLog ? addLog.split("\n").filter(Boolean).pop() : void 0;
+  const gitUpdated = lastLog || void 0;
+  let created = gitCreated;
+  let updated = gitUpdated;
+  if (!created || !updated) {
+    try {
+      const st = await import_promises6.default.stat(absPath);
+      if (!updated) updated = st.mtime.toISOString();
+      if (!created) created = isEpochish(st.birthtime) ? st.mtime.toISOString() : st.birthtime.toISOString();
+    } catch {
+    }
+  }
+  const result = { created, updated };
+  timestampCache.set(absPath, result);
+  return result;
+}
 
 // src/repo.ts
 init_errors();
@@ -974,7 +985,7 @@ async function detectRepoName(cwd) {
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await import_promises6.default.readFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const raw = await import_promises7.default.readFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), "utf8");
     const parsed = (0, import_yaml2.parse)(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
@@ -1004,9 +1015,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await import_promises6.default.mkdir(absWiki, { recursive: true });
+  await import_promises7.default.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await import_promises6.default.writeFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
+  await import_promises7.default.writeFile(import_node_path5.default.join(cwd, REPO_CONFIG_FILE), (0, import_yaml2.stringify)(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -1078,7 +1089,7 @@ async function collectionGitStatus(entry) {
 init_collections();
 
 // src/browse.ts
-var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_promises8 = __toESM(require("fs/promises"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
@@ -1125,7 +1136,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await import_promises7.default.readdir(dir, { withFileTypes: true });
+    dirents = await import_promises8.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -1143,7 +1154,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await import_promises7.default.readdir(dir);
+    return await import_promises8.default.readdir(dir);
   } catch {
     return [];
   }
@@ -1160,7 +1171,7 @@ function pickIndexFile(names) {
 async function cheapTitle(absPath) {
   let handle;
   try {
-    handle = await import_promises7.default.open(absPath, "r");
+    handle = await import_promises8.default.open(absPath, "r");
     const buf = Buffer.alloc(512);
     const { bytesRead } = await handle.read(buf, 0, 512, 0);
     const snippet = buf.subarray(0, bytesRead).toString("utf8");
@@ -1210,11 +1221,12 @@ async function readArticle(coll, slug) {
   const safeSlug = normalized.split("/").filter((s) => s !== "" && s !== ".").join("/");
   const inJail = (p) => p === collDir || p.startsWith(collDir + import_node_path6.default.sep);
   let abs;
+  let isIndex = false;
   for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
     const candidate = import_node_path6.default.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await import_promises7.default.access(candidate);
+      await import_promises8.default.access(candidate);
       abs = candidate;
       break;
     } catch {
@@ -1224,16 +1236,20 @@ async function readArticle(coll, slug) {
     const dir = import_node_path6.default.resolve(collDir, safeSlug);
     if (inJail(dir)) {
       const idx = pickIndexFile(await readdirSafe(dir));
-      if (idx) abs = import_node_path6.default.join(dir, idx);
+      if (idx) {
+        abs = import_node_path6.default.join(dir, idx);
+        isIndex = true;
+      }
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await import_promises7.default.readFile(abs, "utf8"));
+  const parsed = parseArticle(await import_promises8.default.readFile(abs, "utf8"));
   const title = parsed.title?.trim() || (safeSlug ? safeSlug.split("/").pop() ?? safeSlug : coll);
-  return { coll, slug: safeSlug, title, tags: parsed.tags, body: parsed.body, path: abs };
+  return { coll, slug: safeSlug, title, tags: parsed.tags, body: parsed.body, path: abs, isIndex };
 }
 
 // src/render.ts
+var import_node_path7 = __toESM(require("path"), 1);
 var import_unified = require("unified");
 var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_gfm = __toESM(require("remark-gfm"), 1);
@@ -1243,6 +1259,36 @@ var import_rehype = __toESM(require("@shikijs/rehype"), 1);
 var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
 var import_unist_util_visit = require("unist-util-visit");
 var import_hast_util_to_string = require("hast-util-to-string");
+function isNonRelativeHref(href) {
+  if (href === "") return true;
+  if (href.startsWith("/") || href.startsWith("#") || href.startsWith("?")) return true;
+  if (href.startsWith("//")) return true;
+  return /^[a-z][a-z0-9+.-]*:/i.test(href);
+}
+function rehypeRewriteLinks(ctx) {
+  const slugDir = ctx.isIndex ? ctx.slug || "." : import_node_path7.default.posix.dirname(ctx.slug || ".");
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, "element", (node) => {
+      if (node.tagName !== "a") return;
+      const raw = node.properties?.href;
+      if (typeof raw !== "string" || isNonRelativeHref(raw)) return;
+      const suffixMatch = /[#?].*$/.exec(raw);
+      const suffix = suffixMatch ? suffixMatch[0] : "";
+      const pathPart = suffix ? raw.slice(0, raw.length - suffix.length) : raw;
+      if (pathPart === "") return;
+      const joined = import_node_path7.default.posix.join(slugDir === "." ? "" : slugDir, pathPart);
+      const normalized = import_node_path7.default.posix.normalize(joined);
+      if (normalized.startsWith("..")) return;
+      let resolved = normalized.replace(/\.(mdx?)$/i, "");
+      resolved = resolved.replace(/(^|\/)(index|readme)$/i, "$1");
+      resolved = resolved.replace(/\/+$/, "").replace(/^\/+/, "");
+      node.properties = {
+        ...node.properties,
+        href: `/${ctx.coll}${resolved ? `/${resolved}` : ""}${suffix}`
+      };
+    });
+  };
+}
 var LANG_ALIASES = {
   "c#": "csharp",
   cs: "csharp",
@@ -1261,6 +1307,56 @@ function rehypeCollectToc(toc) {
     });
   };
 }
+function isExternalHref(href) {
+  if (!href) return true;
+  if (href.startsWith("#")) return true;
+  if (href.startsWith("//")) return true;
+  return /^[a-z][a-z0-9+.-]*:/i.test(href);
+}
+function resolveHref(href, ctx) {
+  if (isExternalHref(href)) return null;
+  const clean = (p) => p.replace(/[?#].*$/, "").replace(/\.(mdx?|html)$/i, "").replace(/\/+$/, "");
+  const target = clean(href);
+  if (!target) return null;
+  if (target.startsWith("/")) {
+    const base = ctx.base ?? process.env.DIFFWIKI_BASE ?? "";
+    const baseSegs2 = base.split("/").filter(Boolean);
+    let segs = target.split("/").filter(Boolean);
+    if (baseSegs2.length > 0 && baseSegs2.every((b, i) => segs[i] === b)) {
+      segs = segs.slice(baseSegs2.length);
+    }
+    if (segs.length < 2) return null;
+    return segs.join("/");
+  }
+  const dir = ctx.isIndex ? ctx.slug : ctx.slug.includes("/") ? ctx.slug.slice(0, ctx.slug.lastIndexOf("/")) : "";
+  const baseSegs = dir ? dir.split("/") : [];
+  const out = [...baseSegs];
+  for (const seg of target.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length === 0) return null;
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  if (out.length === 0) return null;
+  return `${ctx.coll}/${out.join("/")}`;
+}
+function rehypeCollectLinks(links, ctx) {
+  const seen = /* @__PURE__ */ new Set();
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, "element", (node) => {
+      if (node.tagName !== "a") return;
+      const href = node.properties?.href;
+      if (typeof href !== "string") return;
+      const id = resolveHref(href, ctx);
+      if (!id || seen.has(id)) return;
+      seen.add(id);
+      links.push(id);
+    });
+  };
+}
 function rehypeStripLeadingH1() {
   return (tree) => {
     let removed = false;
@@ -1286,15 +1382,114 @@ function rehypeMarkMermaid() {
     });
   };
 }
-async function renderArticle(body) {
+async function renderArticle(body, ctx) {
   const toc = [];
-  const file = await (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_gfm.default).use(import_remark_rehype.default).use(import_rehype_slug.default).use(rehypeCollectToc, toc).use(rehypeStripLeadingH1).use(rehypeMarkMermaid).use(import_rehype.default, {
+  const links = [];
+  const pipeline = (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_gfm.default).use(import_remark_rehype.default).use(import_rehype_slug.default).use(rehypeCollectToc, toc).use(rehypeCollectLinks, links, ctx);
+  const file = await pipeline.use(rehypeStripLeadingH1).use(rehypeMarkMermaid).use(rehypeRewriteLinks, ctx).use(import_rehype.default, {
     themes: { light: "github-light", dark: "github-dark" },
     defaultColor: false,
     langAlias: LANG_ALIASES,
     fallbackLanguage: "plaintext"
   }).use(import_rehype_stringify.default).process(body);
-  return { html: String(file), toc };
+  return { html: String(file), toc, links };
+}
+
+// src/graph.ts
+init_collections();
+init_errors();
+function tagId(tag) {
+  return `tag:${tag}`;
+}
+async function collectArticle(coll, slug, fallbackTitle, outNodes, outEdges, outTags) {
+  let art;
+  try {
+    art = await readArticle(coll, slug);
+  } catch (err) {
+    if (err instanceof ArticleNotFoundError) return;
+    throw err;
+  }
+  const id = `${coll}/${slug}`;
+  outNodes.push({ id, kind: "article", coll, slug, title: art.title ?? fallbackTitle ?? slug });
+  const { links } = await renderArticle(art.body, { coll, slug, isIndex: art.isIndex });
+  for (const target of links) outEdges.push({ source: id, target, kind: "link" });
+  for (const tag of art.tags) outTags.push({ source: id, tag });
+}
+async function collectCollection(coll, nodes, outNodes, outEdges, outTags) {
+  for (const n of nodes) {
+    if (n.slug) await collectArticle(coll, n.slug, n.title ?? n.name, outNodes, outEdges, outTags);
+    if (n.children) await collectCollection(coll, n.children, outNodes, outEdges, outTags);
+  }
+}
+var cached;
+function invalidateLinkGraph() {
+  cached = void 0;
+}
+async function buildLinkGraph() {
+  if (cached) return cached;
+  const nodes = [];
+  const rawEdges = [];
+  const rawTags = [];
+  for (const e of await listCollections()) {
+    try {
+      await collectArticle(e.name, "", e.name, nodes, rawEdges, rawTags);
+      await collectCollection(e.name, await listArticleTree(e.name), nodes, rawEdges, rawTags);
+    } catch {
+    }
+  }
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const edge of rawEdges) {
+    if (edge.source === edge.target) continue;
+    if (!nodeIds.has(edge.target)) continue;
+    const key = `${edge.source} ${edge.target}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push(edge);
+  }
+  const tagSeen = /* @__PURE__ */ new Set();
+  for (const { source, tag } of rawTags) {
+    if (!nodeIds.has(source)) continue;
+    const id = tagId(tag);
+    if (!tagSeen.has(id)) {
+      tagSeen.add(id);
+      nodes.push({ id, kind: "tag", coll: "", slug: "", title: `#${tag}` });
+    }
+    const key = `${source} ${id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({ source, target: id, kind: "tag" });
+  }
+  cached = { nodes, edges };
+  return cached;
+}
+function localGraph(graph, focusId, include, siblingCap = 12) {
+  const scoped = include ? {
+    // Tag hubs survive the filter — never a page, so they can't 404.
+    nodes: graph.nodes.filter((n) => n.kind === "tag" || include.has(n.coll)),
+    edges: graph.edges
+  } : graph;
+  const byId = new Map(scoped.nodes.map((n) => [n.id, n]));
+  const focus = byId.get(focusId);
+  if (!focus) return { focus: focusId, nodes: [], edges: [] };
+  const keep = /* @__PURE__ */ new Set([focusId]);
+  for (const e of scoped.edges) {
+    if (e.source === focusId && byId.has(e.target)) keep.add(e.target);
+    if (e.target === focusId && byId.has(e.source)) keep.add(e.source);
+  }
+  const focusTagHubs = new Set([...keep].filter((id) => byId.get(id)?.kind === "tag"));
+  let siblings = 0;
+  for (const e of scoped.edges) {
+    if (siblings >= siblingCap) break;
+    if (e.kind === "tag" && focusTagHubs.has(e.target) && byId.has(e.source) && !keep.has(e.source)) {
+      keep.add(e.source);
+      siblings++;
+    }
+  }
+  const nodes = scoped.nodes.filter((n) => keep.has(n.id));
+  const edges = scoped.edges.filter((e) => keep.has(e.source) && keep.has(e.target));
+  return { focus: focusId, nodes, edges };
 }
 
 // src/site.ts
@@ -1348,10 +1543,16 @@ function findNode(nodes, slug) {
   }
   return void 0;
 }
-async function resolvePage(coll, slug) {
+async function resolvePage(coll, slug, opts) {
   try {
     const art = await readArticle(coll, slug);
-    const { html, toc } = await renderArticle(art.body);
+    const { html, toc } = await renderArticle(art.body, {
+      coll: art.coll,
+      slug: art.slug,
+      isIndex: art.isIndex
+    });
+    const { created, updated } = await fileTimestamps(art.path);
+    const graph = localGraph(await buildLinkGraph(), `${art.coll}/${art.slug}`, opts?.include);
     return {
       kind: "doc",
       coll: art.coll,
@@ -1360,7 +1561,10 @@ async function resolvePage(coll, slug) {
       tags: art.tags,
       html,
       toc,
-      path: `/${art.coll}/${art.slug}`
+      path: `/${art.coll}/${art.slug}`,
+      created,
+      updated,
+      graph
     };
   } catch (err) {
     if (err instanceof CollectionNotFoundError) return null;
@@ -1418,8 +1622,8 @@ function resolveCollectionSelection(all, sel = {}) {
 }
 
 // src/query.ts
-var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises9 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 init_collections();
 init_errors();
 init_logger();
@@ -1488,13 +1692,13 @@ var log2 = getLogger("query");
 async function collectMarkdownFiles(dir) {
   let entries;
   try {
-    entries = await import_promises8.default.readdir(dir, { withFileTypes: true });
+    entries = await import_promises9.default.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const full = import_node_path7.default.join(dir, entry.name);
+    const full = import_node_path8.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectMarkdownFiles(full));
     } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
@@ -1513,12 +1717,12 @@ async function nativeSearch(term, collections, collection) {
   const docs = [];
   for (const entry of targets) {
     for (const full of await collectMarkdownFiles(entry.path)) {
-      const fallbackTitle = import_node_path7.default.basename(full).replace(/\.mdx?$/, "");
+      const fallbackTitle = import_node_path8.default.basename(full).replace(/\.mdx?$/, "");
       let title = fallbackTitle;
       let tags = [];
       let body = "";
       try {
-        const parsed = parseArticle(await import_promises8.default.readFile(full, "utf8"));
+        const parsed = parseArticle(await import_promises9.default.readFile(full, "utf8"));
         if (parsed.title) title = parsed.title;
         tags = parsed.tags;
         body = parsed.body;
@@ -1601,13 +1805,13 @@ async function query(term, opts) {
 }
 
 // src/search.ts
-var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 init_collections();
 async function readArticleParts(collDir, slug) {
   for (const ext of [".mdx", ".md"]) {
     try {
-      const parsed = parseArticle(await import_promises9.default.readFile(import_node_path8.default.join(collDir, `${slug}${ext}`), "utf8"));
+      const parsed = parseArticle(await import_promises10.default.readFile(import_node_path9.default.join(collDir, `${slug}${ext}`), "utf8"));
       return { tags: parsed.tags, body: parsed.body };
     } catch {
     }
@@ -1641,7 +1845,7 @@ async function buildSearchIndex(collection) {
   for (const e of entries) {
     try {
       const collEntry = await findCollection(e.name);
-      const collDir = import_node_path8.default.resolve(collEntry?.path ?? e.path);
+      const collDir = import_node_path9.default.resolve(collEntry?.path ?? e.path);
       await flatten(e.name, collDir, await listArticleTree(e.name), out);
     } catch {
     }
@@ -1650,15 +1854,15 @@ async function buildSearchIndex(collection) {
 }
 
 // src/doctor.ts
-var import_promises11 = __toESM(require("fs/promises"), 1);
+var import_promises12 = __toESM(require("fs/promises"), 1);
 init_paths();
 init_registry();
 init_collections();
 
 // src/plugins/manager.ts
-var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_promises11 = __toESM(require("fs/promises"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 init_paths();
 init_errors();
 init_collections();
@@ -1669,7 +1873,7 @@ init_host();
 var import_node_child_process4 = require("child_process");
 var import_node_util3 = require("util");
 var import_node_fs = require("fs");
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 var import_node_url = require("url");
 var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
 async function runProcess(file, args, opts) {
@@ -1685,7 +1889,7 @@ async function runProcess(file, args, opts) {
 // src/plugins/manager.ts
 async function readPackageJson(file) {
   try {
-    return JSON.parse(await import_promises10.default.readFile(file, "utf8"));
+    return JSON.parse(await import_promises11.default.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -1701,7 +1905,7 @@ function binOf(manifest) {
 async function pluginManifestDirs(nodeModules) {
   let entries;
   try {
-    entries = await import_promises10.default.readdir(nodeModules);
+    entries = await import_promises11.default.readdir(nodeModules);
   } catch {
     return [];
   }
@@ -1711,44 +1915,44 @@ async function pluginManifestDirs(nodeModules) {
     if (entry.startsWith("@")) {
       let scoped;
       try {
-        scoped = await import_promises10.default.readdir(import_node_path10.default.join(nodeModules, entry));
+        scoped = await import_promises11.default.readdir(import_node_path11.default.join(nodeModules, entry));
       } catch {
         continue;
       }
       for (const pkg of scoped) {
         if (pkg.startsWith(".")) continue;
-        dirs.push(import_node_path10.default.join(nodeModules, entry, pkg));
+        dirs.push(import_node_path11.default.join(nodeModules, entry, pkg));
       }
     } else {
-      dirs.push(import_node_path10.default.join(nodeModules, entry));
+      dirs.push(import_node_path11.default.join(nodeModules, entry));
     }
   }
   return dirs;
 }
 async function ensurePluginRoot() {
   const dir = pluginsDir();
-  await import_promises10.default.mkdir(dir, { recursive: true });
-  const pkgPath = import_node_path10.default.join(dir, "package.json");
+  await import_promises11.default.mkdir(dir, { recursive: true });
+  const pkgPath = import_node_path11.default.join(dir, "package.json");
   if (await readPackageJson(pkgPath) === null) {
     const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
-    await import_promises10.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    await import_promises11.default.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
   }
   return dir;
 }
 async function asSearchPackage(pkgDir) {
-  const manifest = await readPackageJson(import_node_path10.default.join(pkgDir, "package.json"));
+  const manifest = await readPackageJson(import_node_path11.default.join(pkgDir, "package.json"));
   if (!manifest?.name || manifest.diffwiki?.kind !== "search") return null;
   const bin = binOf(manifest);
   if (!bin) return null;
-  return { name: manifest.name, version: manifest.version, binAbs: import_node_path10.default.resolve(pkgDir, bin) };
+  return { name: manifest.name, version: manifest.version, binAbs: import_node_path11.default.resolve(pkgDir, bin) };
 }
 async function packageNameFromSpec(spec) {
   const looksLikePath = spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("~") || spec.startsWith("file:");
   if (looksLikePath) {
     const raw = spec.startsWith("file:") ? spec.slice("file:".length) : spec;
-    const abs = import_node_path10.default.resolve(raw.replace(/^~(?=$|\/)/, import_node_os2.default.homedir()));
-    return (await readPackageJson(import_node_path10.default.join(abs, "package.json")))?.name ?? null;
+    const abs = import_node_path11.default.resolve(raw.replace(/^~(?=$|\/)/, import_node_os2.default.homedir()));
+    return (await readPackageJson(import_node_path11.default.join(abs, "package.json")))?.name ?? null;
   }
   if (/^(git\+|git:|https?:|ssh:)/.test(spec)) return null;
   if (spec.startsWith("@")) {
@@ -1759,10 +1963,10 @@ async function packageNameFromSpec(spec) {
   return at <= 0 ? spec : spec.slice(0, at);
 }
 async function resolveSearchPackage(dir, name) {
-  return asSearchPackage(import_node_path10.default.join(dir, "node_modules", ...name.split("/")));
+  return asSearchPackage(import_node_path11.default.join(dir, "node_modules", ...name.split("/")));
 }
 async function discoverSearchPackage(dir) {
-  const nodeModules = import_node_path10.default.join(dir, "node_modules");
+  const nodeModules = import_node_path11.default.join(dir, "node_modules");
   for (const pkgDir of await pluginManifestDirs(nodeModules)) {
     const found = await asSearchPackage(pkgDir);
     if (found) return found;
@@ -1894,7 +2098,7 @@ init_host();
 init_types();
 async function exists(target) {
   try {
-    await import_promises11.default.access(target);
+    await import_promises12.default.access(target);
     return true;
   } catch {
     return false;
@@ -2047,6 +2251,7 @@ init_registry2();
   addTags,
   buildArticleTree,
   buildCollections,
+  buildLinkGraph,
   buildNavTree,
   buildSearchIndex,
   collectionDir,
@@ -2061,6 +2266,7 @@ init_registry2();
   emitPluginEvent,
   ensureGitRepo,
   ensurePluginRoot,
+  fileTimestamps,
   findCollection,
   findCollectionById,
   findEnabledPlugin,
@@ -2070,6 +2276,7 @@ init_registry2();
   gitToplevel,
   initRepoWiki,
   installPlugin,
+  invalidateLinkGraph,
   isLinkedWorktree,
   listArticleTree,
   listAvailablePlugins,
@@ -2078,6 +2285,7 @@ init_registry2();
   listPlugins,
   listSearchModes,
   loadSearchProvider,
+  localGraph,
   nativeSearch,
   parseAddTarget,
   parseArticle,