@tangle-network/agent-knowledge 0.1.0

package/dist/chunk-XDXIBHPS.js

@@ -0,0 +1,703 @@
+// src/ids.ts
+import { createHash } from "crypto";
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function slugify(input) {
+  const out = input.trim().toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "");
+  return out || "untitled";
+}
+function stableId(prefix, content) {
+  return `${prefix}_${sha256(content).slice(0, 16)}`;
+}
+
+// src/frontmatter.ts
+function parseFrontmatter(content) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---\n")) return { frontmatter: {}, body: normalized };
+  const end = normalized.indexOf("\n---", 4);
+  if (end < 0) return { frontmatter: {}, body: normalized };
+  const raw = normalized.slice(4, end);
+  const after = normalized.slice(end).replace(/^\n---\s*\n?/, "");
+  return { frontmatter: parseSimpleYaml(raw), body: after };
+}
+function formatFrontmatter(frontmatter, body) {
+  const lines = Object.entries(frontmatter).filter(([, value]) => value !== void 0).flatMap(([key, value]) => formatYamlField(key, value));
+  if (lines.length === 0) return body;
+  return `---
+${lines.join("\n")}
+---
+${body.replace(/^\n+/, "")}`;
+}
+function parseSimpleYaml(raw) {
+  const out = {};
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const scalar = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+    if (!scalar) continue;
+    const key = scalar[1];
+    const rest = scalar[2].trim();
+    if (rest === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const item = /^\s*-\s*(.+?)\s*$/.exec(lines[i + 1]);
+        if (!item) break;
+        items.push(unquote(item[1]));
+        i++;
+      }
+      out[key] = items;
+      continue;
+    }
+    if (rest.startsWith("[") && rest.endsWith("]")) {
+      out[key] = rest.slice(1, -1).split(",").map((part) => unquote(part.trim())).filter(Boolean);
+    } else if (rest === "true" || rest === "false") {
+      out[key] = rest === "true";
+    } else if (/^-?\d+(?:\.\d+)?$/.test(rest)) {
+      out[key] = Number(rest);
+    } else {
+      out[key] = unquote(rest);
+    }
+  }
+  return out;
+}
+function formatYamlField(key, value) {
+  if (Array.isArray(value)) {
+    return [key + ":", ...value.map((item) => `  - ${String(item)}`)];
+  }
+  if (typeof value === "string") return [`${key}: ${value}`];
+  if (typeof value === "number" || typeof value === "boolean") return [`${key}: ${String(value)}`];
+  return [`${key}: ${JSON.stringify(value)}`];
+}
+function unquote(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+
+// src/wikilinks.ts
+var WIKILINK_REGEX = /\[\[([^\]|]+?)(?:\|[^\]]+?)?\]\]/g;
+function extractWikilinks(content) {
+  const links = [];
+  const regex = new RegExp(WIKILINK_REGEX.source, "g");
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    links.push(match[1].trim());
+  }
+  return [...new Set(links)];
+}
+function normalizeLinkTarget(target) {
+  return target.trim().replace(/\.md$/i, "").toLowerCase().replace(/\s+/g, "-");
+}
+
+// src/write-protocol.ts
+var OPENER_LINE = /^---\s*FILE:\s*(.+?)\s*---\s*$/i;
+var CLOSER_LINE = /^---\s*END\s+FILE\s*---\s*$/i;
+var FENCE_LINE = /^\s{0,3}(```+|~~~+)/;
+function isSafeKnowledgePath(path, allowedPrefixes = ["knowledge/"]) {
+  if (typeof path !== "string" || path.trim() === "") return false;
+  if (/[\x00-\x1f]/.test(path)) return false;
+  if (path.startsWith("/") || path.startsWith("\\")) return false;
+  if (/^[a-zA-Z]:/.test(path)) return false;
+  const normalized = path.replace(/\\/g, "/");
+  if (normalized.split("/").some((part) => part === "..")) return false;
+  return allowedPrefixes.some((prefix) => normalized.startsWith(prefix));
+}
+function parseKnowledgeWriteBlocks(text, allowedPrefixes = ["knowledge/"]) {
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  const warnings = [];
+  let i = 0;
+  while (i < lines.length) {
+    const opener = OPENER_LINE.exec(lines[i]);
+    if (!opener) {
+      i++;
+      continue;
+    }
+    const path = opener[1].trim();
+    i++;
+    const contentLines = [];
+    let fenceMarker = null;
+    let fenceLen = 0;
+    let closed = false;
+    while (i < lines.length) {
+      const line = lines[i];
+      const fence = FENCE_LINE.exec(line);
+      if (fence) {
+        const run = fence[1];
+        const char = run[0];
+        if (fenceMarker === null) {
+          fenceMarker = char;
+          fenceLen = run.length;
+        } else if (char === fenceMarker && run.length >= fenceLen) {
+          fenceMarker = null;
+          fenceLen = 0;
+        }
+        contentLines.push(line);
+        i++;
+        continue;
+      }
+      if (fenceMarker === null && CLOSER_LINE.test(line)) {
+        closed = true;
+        i++;
+        break;
+      }
+      contentLines.push(line);
+      i++;
+    }
+    if (!closed) {
+      warnings.push(`FILE block "${path || "(empty)"}" was not closed before end of stream.`);
+      continue;
+    }
+    if (!isSafeKnowledgePath(path, allowedPrefixes)) {
+      warnings.push(`FILE block with unsafe path "${path}" rejected.`);
+      continue;
+    }
+    blocks.push({ path, content: contentLines.join("\n") });
+  }
+  return { blocks, warnings };
+}
+
+// src/adapters.ts
+var textSourceAdapter = {
+  id: "text",
+  canLoad: (input) => Boolean(input.text) || /\.(md|txt|json|csv)$/i.test(input.uri),
+  load: (input) => ({
+    title: input.uri.split("/").pop(),
+    mediaType: mediaTypeFor(input.uri),
+    text: decodeText(input),
+    anchors: anchorsForText(input.uri, decodeText(input)),
+    metadata: input.metadata
+  })
+};
+function mediaTypeFor(uri) {
+  const lower = uri.toLowerCase();
+  if (lower.endsWith(".md")) return "text/markdown";
+  if (lower.endsWith(".txt")) return "text/plain";
+  if (lower.endsWith(".json")) return "application/json";
+  if (lower.endsWith(".csv")) return "text/csv";
+  if (lower.endsWith(".pdf")) return "application/pdf";
+  return "application/octet-stream";
+}
+function decodeText(input) {
+  return input.text ?? (input.bytes ? new TextDecoder().decode(input.bytes).slice(0, 2e5) : void 0);
+}
+function anchorsForText(uri, text) {
+  if (!text) return [];
+  const lines = text.split("\n");
+  const anchors = [{ id: "all", sourceId: "", label: "Full source", lineStart: 1, lineEnd: lines.length }];
+  for (let i = 0; i < lines.length; i += 50) {
+    anchors.push({
+      id: `l${i + 1}`,
+      sourceId: "",
+      label: `${uri}:${i + 1}`,
+      lineStart: i + 1,
+      lineEnd: Math.min(lines.length, i + 50)
+    });
+  }
+  return anchors;
+}
+
+// src/proposals.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+async function applyKnowledgeWriteBlocks(root, proposalText) {
+  const parsed = parseKnowledgeWriteBlocks(proposalText);
+  const written = [];
+  for (const block of parsed.blocks) {
+    const path = join(root, block.path);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, block.content.endsWith("\n") ? block.content : `${block.content}
+`, "utf8");
+    written.push(block.path);
+  }
+  return { written, warnings: parsed.warnings };
+}
+async function applyKnowledgeWriteBlocksFile(root, proposalPath) {
+  return applyKnowledgeWriteBlocks(root, await readFile(proposalPath, "utf8"));
+}
+
+// src/store.ts
+import { mkdir as mkdir2, readFile as readFile2, readdir, stat, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2, relative } from "path";
+function layoutFor(root) {
+  return {
+    root,
+    knowledgeDir: join2(root, "knowledge"),
+    rawSourcesDir: join2(root, "raw", "sources"),
+    sourceRegistryPath: join2(root, ".agent-knowledge", "sources.json"),
+    indexPath: join2(root, "knowledge", "index.md"),
+    logPath: join2(root, "knowledge", "log.md"),
+    cacheDir: join2(root, ".agent-knowledge")
+  };
+}
+async function initKnowledgeBase(root) {
+  const layout = layoutFor(root);
+  await mkdir2(layout.knowledgeDir, { recursive: true });
+  await mkdir2(layout.rawSourcesDir, { recursive: true });
+  await mkdir2(layout.cacheDir, { recursive: true });
+  await writeIfMissing(layout.indexPath, "# Knowledge Index\n\n");
+  await writeIfMissing(layout.logPath, "# Knowledge Log\n\n");
+  await writeIfMissing(layout.sourceRegistryPath, '{\n  "generatedAt": "1970-01-01T00:00:00.000Z",\n  "sources": []\n}\n');
+  return layout;
+}
+async function loadKnowledgePages(root) {
+  const layout = layoutFor(root);
+  const files = await listMarkdownFiles(layout.knowledgeDir);
+  const pages = [];
+  for (const file of files) {
+    const content = await readFile2(file, "utf8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    const rel = relative(root, file).replace(/\\/g, "/");
+    const title = stringField(frontmatter.title) ?? firstHeading(body) ?? rel.split("/").pop().replace(/\.md$/, "");
+    const sourceIds = arrayField(frontmatter.sources);
+    const tags = arrayField(frontmatter.tags);
+    pages.push({
+      id: stringField(frontmatter.id) ?? slugify(rel.replace(/^knowledge\//, "").replace(/\.md$/, "")),
+      path: rel,
+      title,
+      text: body,
+      frontmatter,
+      sourceIds,
+      tags,
+      outLinks: extractWikilinks(body).map(normalizeLinkTarget)
+    });
+  }
+  pages.sort((a, b) => a.path.localeCompare(b.path));
+  return pages;
+}
+async function writeJson(path, value) {
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+async function writeIfMissing(path, content) {
+  try {
+    await stat(path);
+  } catch {
+    await mkdir2(dirname2(path), { recursive: true });
+    await writeFile2(path, content, "utf8");
+  }
+}
+async function listMarkdownFiles(root) {
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      const full = join2(root, entry.name);
+      if (entry.isDirectory()) out.push(...await listMarkdownFiles(full));
+      else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function arrayField(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function firstHeading(body) {
+  return /^#\s+(.+)$/m.exec(body)?.[1]?.trim();
+}
+
+// src/sources.ts
+import { copyFile, mkdir as mkdir3, readFile as readFile3, readdir as readdir2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { basename, dirname as dirname3, join as join3, relative as relative2 } from "path";
+async function loadSourceRegistry(root) {
+  const path = sourceRegistryPath(root);
+  try {
+    const parsed = JSON.parse(await readFile3(path, "utf8"));
+    return {
+      generatedAt: typeof parsed.generatedAt === "string" ? parsed.generatedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+      sources: Array.isArray(parsed.sources) ? parsed.sources : []
+    };
+  } catch {
+    return { generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(), sources: [] };
+  }
+}
+async function writeSourceRegistry(root, registry) {
+  const path = sourceRegistryPath(root);
+  await mkdir3(dirname3(path), { recursive: true });
+  await writeFile3(path, JSON.stringify(registry, null, 2) + "\n", "utf8");
+}
+async function addSourcePath(root, sourcePath, options = {}) {
+  const s = await stat2(sourcePath);
+  if (s.isDirectory()) {
+    const out = [];
+    for (const file of await listFiles(sourcePath)) {
+      out.push(...await addSourcePath(root, file, options));
+    }
+    return out;
+  }
+  const layout = layoutFor(root);
+  await mkdir3(layout.rawSourcesDir, { recursive: true });
+  const bytes = await readFile3(sourcePath);
+  const contentHash = sha256(bytes.toString("base64"));
+  const fileName = basename(sourcePath);
+  const adapters = options.adapters ?? [textSourceAdapter];
+  const adapter = adapters.find((candidate) => candidate.canLoad({ uri: sourcePath, bytes }));
+  const loaded = adapter ? await adapter.load({ uri: sourcePath, bytes }) : {};
+  const id = stableId("src", `${contentHash}:${fileName}`);
+  const targetRel = join3("raw", "sources", `${slugify(fileName.replace(/\.[^.]+$/, ""))}-${contentHash.slice(0, 8)}${ext(fileName)}`).replace(/\\/g, "/");
+  const targetAbs = join3(root, targetRel);
+  if (options.copyIntoRaw ?? true) {
+    await mkdir3(dirname3(targetAbs), { recursive: true });
+    await copyFile(sourcePath, targetAbs);
+  }
+  const existing = await loadSourceRegistry(root);
+  const record = {
+    id,
+    uri: targetRel,
+    title: loaded.title ?? fileName,
+    mediaType: loaded.mediaType ?? mediaTypeFor2(fileName),
+    contentHash,
+    text: loaded.text ?? textPreview(fileName, bytes),
+    anchors: (loaded.anchors ?? []).map((anchor) => ({ ...anchor, sourceId: id })),
+    createdAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    metadata: {
+      ...loaded.metadata ?? {},
+      originalPath: sourcePath,
+      sizeBytes: bytes.length,
+      projectRelativePath: relative2(root, sourcePath).replace(/\\/g, "/")
+    }
+  };
+  const next = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sources: [record, ...existing.sources.filter((source) => source.id !== id)]
+  };
+  await writeSourceRegistry(root, next);
+  return [record];
+}
+function sourceRegistryPath(root) {
+  return join3(layoutFor(root).cacheDir, "sources.json");
+}
+async function listFiles(root) {
+  const entries = await readdir2(root, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const full = join3(root, entry.name);
+    if (entry.isDirectory()) out.push(...await listFiles(full));
+    else if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+function ext(fileName) {
+  const idx = fileName.lastIndexOf(".");
+  return idx >= 0 ? fileName.slice(idx) : "";
+}
+function mediaTypeFor2(fileName) {
+  const lower = fileName.toLowerCase();
+  if (lower.endsWith(".md")) return "text/markdown";
+  if (lower.endsWith(".txt")) return "text/plain";
+  if (lower.endsWith(".json")) return "application/json";
+  if (lower.endsWith(".csv")) return "text/csv";
+  if (lower.endsWith(".pdf")) return "application/pdf";
+  return "application/octet-stream";
+}
+function textPreview(fileName, bytes) {
+  const mediaType = mediaTypeFor2(fileName);
+  if (!mediaType.startsWith("text/") && mediaType !== "application/json") return void 0;
+  return bytes.toString("utf8").slice(0, 2e5);
+}
+
+// src/graph.ts
+function buildKnowledgeGraph(pages) {
+  const byId = /* @__PURE__ */ new Map();
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    byId.set(page.id, page);
+    bySlug.set(normalizeLinkTarget(page.id), page);
+    bySlug.set(normalizeLinkTarget(page.title), page);
+    bySlug.set(normalizeLinkTarget(page.path.split("/").pop().replace(/\.md$/, "")), page);
+  }
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  const edgesByKey = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    outgoing.set(page.id, 0);
+    incoming.set(page.id, 0);
+  }
+  for (const page of pages) {
+    for (const raw of page.outLinks) {
+      const target = bySlug.get(normalizeLinkTarget(raw));
+      if (!target || target.id === page.id) continue;
+      const key = `${page.id}->${target.id}`;
+      const edge = edgesByKey.get(key);
+      if (edge) edge.weight += 1;
+      else edgesByKey.set(key, { source: page.id, target: target.id, weight: 1, reasons: ["wikilink"] });
+      outgoing.set(page.id, (outgoing.get(page.id) ?? 0) + 1);
+      incoming.set(target.id, (incoming.get(target.id) ?? 0) + 1);
+    }
+  }
+  addSourceOverlapEdges(pages, edgesByKey);
+  const nodes = pages.map((page) => ({
+    id: page.id,
+    title: page.title,
+    path: page.path,
+    tags: page.tags,
+    sourceIds: page.sourceIds,
+    outDegree: outgoing.get(page.id) ?? 0,
+    inDegree: incoming.get(page.id) ?? 0
+  }));
+  return { nodes, edges: [...edgesByKey.values()].sort((a, b) => b.weight - a.weight) };
+}
+function addSourceOverlapEdges(pages, edges) {
+  for (let i = 0; i < pages.length; i++) {
+    for (let j = i + 1; j < pages.length; j++) {
+      const a = pages[i];
+      const b = pages[j];
+      const overlap = a.sourceIds.filter((source) => b.sourceIds.includes(source));
+      if (overlap.length === 0) continue;
+      const key = `${a.id}->${b.id}`;
+      const edge = edges.get(key);
+      if (edge) {
+        edge.weight += overlap.length * 0.5;
+        edge.reasons.push("shared-source");
+      } else {
+        edges.set(key, {
+          source: a.id,
+          target: b.id,
+          weight: overlap.length * 0.5,
+          reasons: ["shared-source"]
+        });
+      }
+    }
+  }
+}
+
+// src/search.ts
+var RRF_K = 60;
+var STOP_WORDS = /* @__PURE__ */ new Set(["the", "is", "a", "an", "what", "how", "are", "was", "were", "to", "for", "of", "with", "by", "in", "on", "and"]);
+function searchKnowledge(index, query, limit = 10) {
+  const trimmed = query.trim();
+  if (trimmed === "") return [];
+  const tokenRanked = rankByTokens(index.pages, trimmed);
+  const graphRanked = rankByGraph(index.pages, tokenRanked);
+  const scores = reciprocalRankFusion([tokenRanked.map((p) => p.id), graphRanked.map((p) => p.id)]);
+  const byId = new Map(index.pages.map((page) => [page.id, page]));
+  return [...scores.entries()].map(([id, score]) => ({ page: byId.get(id), score })).filter((item) => Boolean(item.page)).sort((a, b) => b.score - a.score || a.page.path.localeCompare(b.page.path)).slice(0, limit).map((item, i) => ({
+    page: item.page,
+    score: item.score,
+    rank: i + 1,
+    snippet: buildSnippet(item.page.text, trimmed),
+    reasons: reasonsFor(item.page, trimmed)
+  }));
+}
+function tokenizeQuery(query) {
+  const raw = query.toLowerCase().split(/[\s,，。！？、；：""''（）()\-_/\\·~～…]+/).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+  const tokens = [];
+  for (const token of raw) {
+    if (/[\u4e00-\u9fff\u3400-\u4dbf]/.test(token) && token.length > 2) {
+      const chars = [...token];
+      for (let i = 0; i < chars.length - 1; i++) tokens.push(chars[i] + chars[i + 1]);
+      tokens.push(...chars);
+    }
+    tokens.push(token);
+  }
+  return [...new Set(tokens)];
+}
+function reciprocalRankFusion(rankLists, k = RRF_K) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const list of rankLists) {
+    list.forEach((id, idx) => {
+      scores.set(id, (scores.get(id) ?? 0) + 1 / (k + idx + 1));
+    });
+  }
+  return scores;
+}
+function rankByTokens(pages, query) {
+  const tokens = tokenizeQuery(query);
+  const effective = tokens.length > 0 ? tokens : [query.toLowerCase()];
+  return pages.map((page) => ({ page, score: tokenScore(page, query, effective) })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || a.page.path.localeCompare(b.page.path)).map((item) => item.page);
+}
+function rankByGraph(pages, tokenRanked) {
+  if (tokenRanked.length === 0) return [];
+  const seeds = new Set(tokenRanked.slice(0, 5).map((page) => page.id));
+  return pages.map((page) => ({
+    page,
+    score: page.outLinks.filter((link) => seeds.has(link)).length + page.sourceIds.filter((source) => tokenRanked.some((seed) => seed.sourceIds.includes(source))).length
+  })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || a.page.path.localeCompare(b.page.path)).map((item) => item.page);
+}
+function tokenScore(page, query, tokens) {
+  const title = page.title.toLowerCase();
+  const path = page.path.toLowerCase();
+  const body = page.text.toLowerCase();
+  const phrase = query.toLowerCase();
+  let score = 0;
+  if (path.endsWith(`${phrase}.md`) || title === phrase) score += 200;
+  if (title.includes(phrase)) score += 50;
+  if (body.includes(phrase)) score += 20;
+  for (const token of tokens) {
+    if (title.includes(token)) score += 5;
+    if (body.includes(token)) score += 1;
+    if (path.includes(token)) score += 3;
+  }
+  return score;
+}
+function buildSnippet(text, query) {
+  const compact = text.replace(/\s+/g, " ").trim();
+  const idx = compact.toLowerCase().indexOf(query.toLowerCase());
+  if (idx < 0) return compact.slice(0, 180);
+  return compact.slice(Math.max(0, idx - 80), Math.min(compact.length, idx + query.length + 100));
+}
+function reasonsFor(page, query) {
+  const lower = `${page.title}
+${page.text}`.toLowerCase();
+  const reasons = [];
+  if (lower.includes(query.toLowerCase())) reasons.push("phrase");
+  if (page.sourceIds.length > 0) reasons.push("sourced");
+  if (page.outLinks.length > 0) reasons.push("linked");
+  return reasons;
+}
+
+// src/indexer.ts
+import { join as join4 } from "path";
+async function buildKnowledgeIndex(root) {
+  const [pages, sourceRegistry] = await Promise.all([
+    loadKnowledgePages(root),
+    loadSourceRegistry(root)
+  ]);
+  const index = {
+    root,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sources: sourceRegistry.sources,
+    pages,
+    graph: buildKnowledgeGraph(pages)
+  };
+  return index;
+}
+async function writeKnowledgeIndex(root) {
+  const index = await buildKnowledgeIndex(root);
+  await writeJson(join4(layoutFor(root).cacheDir, "index.json"), index);
+  return index;
+}
+
+// src/lint.ts
+function lintKnowledgeIndex(index) {
+  const findings = [];
+  const byTarget = /* @__PURE__ */ new Set();
+  const titles = /* @__PURE__ */ new Map();
+  const sourceIds = new Set(index.sources.map((source) => source.id));
+  const anchorIds = new Map(index.sources.map((source) => [source.id, new Set((source.anchors ?? []).map((anchor) => anchor.id))]));
+  for (const page of index.pages) {
+    byTarget.add(normalizeLinkTarget(page.id));
+    byTarget.add(normalizeLinkTarget(page.title));
+    byTarget.add(normalizeLinkTarget(page.path.split("/").pop().replace(/\.md$/, "")));
+    const titleKey = page.title.toLowerCase();
+    titles.set(titleKey, [...titles.get(titleKey) ?? [], page.path]);
+  }
+  const inbound = /* @__PURE__ */ new Map();
+  for (const page of index.pages) inbound.set(page.id, 0);
+  for (const page of index.pages) {
+    if (page.outLinks.length === 0 && !isStructural(page.path)) {
+      findings.push({ type: "no-outlinks", severity: "info", page: page.path, message: "Page has no wikilinks to other knowledge pages." });
+    }
+    for (const link of page.outLinks) {
+      if (!byTarget.has(normalizeLinkTarget(link))) {
+        findings.push({ type: "broken-link", severity: "warning", page: page.path, message: `Broken wikilink [[${link}]].` });
+      }
+    }
+  }
+  for (const edge of index.graph.edges) inbound.set(edge.target, (inbound.get(edge.target) ?? 0) + 1);
+  for (const page of index.pages) {
+    if (!isStructural(page.path) && (inbound.get(page.id) ?? 0) === 0) {
+      findings.push({ type: "orphan", severity: "info", page: page.path, message: "No other page links to this page." });
+    }
+    if (/\bclaim\b/i.test(page.text) && page.sourceIds.length === 0) {
+      findings.push({ type: "uncited-claim", severity: "warning", page: page.path, message: "Page appears to contain claims but has no sources frontmatter." });
+    }
+    for (const sourceId of page.sourceIds) {
+      if (!sourceIds.has(sourceId)) {
+        findings.push({ type: "missing-source", severity: "error", page: page.path, message: `Page cites unknown source "${sourceId}".`, metadata: { sourceId } });
+      }
+    }
+    for (const ref of extractSourceRefs(page.text)) {
+      if (!sourceIds.has(ref.sourceId)) {
+        findings.push({ type: "missing-source", severity: "error", page: page.path, message: `Page cites unknown source "${ref.sourceId}".`, metadata: ref });
+      } else if (ref.anchorId && !anchorIds.get(ref.sourceId)?.has(ref.anchorId)) {
+        findings.push({ type: "missing-source", severity: "error", page: page.path, message: `Page cites unknown source anchor "${ref.sourceId}#${ref.anchorId}".`, metadata: ref });
+      }
+    }
+  }
+  for (const [title, paths] of titles) {
+    if (title && paths.length > 1) {
+      findings.push({ type: "duplicate-title", severity: "warning", message: `Duplicate title "${title}" in ${paths.join(", ")}.`, metadata: { paths } });
+    }
+  }
+  return findings;
+}
+function isStructural(path) {
+  return path.endsWith("/index.md") || path.endsWith("/log.md") || path === "knowledge/index.md" || path === "knowledge/log.md";
+}
+function extractSourceRefs(text) {
+  const refs = [];
+  const regex = /\[\^([A-Za-z0-9_-]+)(?:#([A-Za-z0-9_.:-]+))?\]/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    refs.push({ sourceId: match[1], anchorId: match[2] });
+  }
+  return refs;
+}
+
+// src/inspect.ts
+function inspectKnowledgeIndex(index) {
+  const findings = lintKnowledgeIndex(index);
+  const degree = new Map(index.graph.nodes.map((node) => [node.id, node.inDegree + node.outDegree]));
+  return {
+    pageCount: index.pages.length,
+    sourceCount: index.sources.length,
+    edgeCount: index.graph.edges.length,
+    findingCount: findings.length,
+    blockingFindingCount: findings.filter((finding) => finding.severity === "error").length,
+    topPages: [...index.pages].sort((a, b) => (degree.get(b.id) ?? 0) - (degree.get(a.id) ?? 0)).slice(0, 10).map((page) => ({ path: page.path, title: page.title, degree: degree.get(page.id) ?? 0, sources: page.sourceIds.length })),
+    findings
+  };
+}
+function explainKnowledgeTarget(index, target) {
+  const page = index.pages.find((candidate) => candidate.path === target || candidate.id === target || candidate.title.toLowerCase() === target.toLowerCase());
+  const inbound = page ? index.graph.edges.filter((edge) => edge.target === page.id).map((edge) => index.pages.find((candidate) => candidate.id === edge.source)?.path ?? edge.source) : [];
+  const related = page ? searchKnowledge(index, `${page.title} ${page.tags.join(" ")}`, 6).filter((result) => result.page.id !== page.id).map((result) => ({ path: result.page.path, title: result.page.title, score: result.score })) : searchKnowledge(index, target, 6).map((result) => ({ path: result.page.path, title: result.page.title, score: result.score }));
+  return {
+    target,
+    page,
+    sources: page ? index.sources.filter((source) => page.sourceIds.includes(source.id)).map((source) => ({ id: source.id, title: source.title, uri: source.uri })) : [],
+    links: page?.outLinks ?? [],
+    inbound,
+    related
+  };
+}
+
+export {
+  sha256,
+  slugify,
+  stableId,
+  parseFrontmatter,
+  formatFrontmatter,
+  WIKILINK_REGEX,
+  extractWikilinks,
+  normalizeLinkTarget,
+  isSafeKnowledgePath,
+  parseKnowledgeWriteBlocks,
+  textSourceAdapter,
+  mediaTypeFor,
+  applyKnowledgeWriteBlocks,
+  applyKnowledgeWriteBlocksFile,
+  layoutFor,
+  initKnowledgeBase,
+  loadKnowledgePages,
+  writeJson,
+  loadSourceRegistry,
+  writeSourceRegistry,
+  addSourcePath,
+  sourceRegistryPath,
+  buildKnowledgeGraph,
+  searchKnowledge,
+  tokenizeQuery,
+  reciprocalRankFusion,
+  buildKnowledgeIndex,
+  writeKnowledgeIndex,
+  lintKnowledgeIndex,
+  inspectKnowledgeIndex,
+  explainKnowledgeTarget
+};
+//# sourceMappingURL=chunk-XDXIBHPS.js.map