mdcontext 0.1.0 → 0.2.0

package/dist/chunk-S7E6TFX6.js

@@ -1,85 +1,104 @@
 // src/utils/tokens.ts
 import { Effect } from "effect";
+
 var encoder = null;
 var getEncoder = Effect.gen(function* () {
-  if (encoder === null) {
-    const { get_encoding } = yield* Effect.promise(() => import("tiktoken"));
-    encoder = get_encoding("cl100k_base");
-  }
-  return encoder;
-});
-var countTokens = (text) => Effect.gen(function* () {
-  const enc = yield* getEncoder;
-  const tokens = enc.encode(text);
-  return tokens.length;
+	if (encoder === null) {
+		const { get_encoding } = yield* Effect.promise(() => import("tiktoken"));
+		encoder = get_encoding("cl100k_base");
+	}
+	return encoder;
 });
+var countTokens = (text) =>
+	Effect.gen(function* () {
+		const enc = yield* getEncoder;
+		const tokens = enc.encode(text);
+		return tokens.length;
+	});
 var countTokensApprox = (text) => {
-  if (text.length === 0) return 0;
-  const cjkPattern = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u3400-\u4dbf]/g;
-  const cjkMatches = text.match(cjkPattern) || [];
-  const cjkCount = cjkMatches.length;
-  const emojiPattern = /[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2300}-\u{23FF}\u{2190}-\u{21FF}\u{25A0}-\u{25FF}\u{2B00}-\u{2BFF}]/gu;
-  const emojiMatches = text.match(emojiPattern) || [];
-  const emojiCount = emojiMatches.length;
-  const variationSelectorPattern = /[\uFE0E\uFE0F]/g;
-  const variationMatches = text.match(variationSelectorPattern) || [];
-  const variationCount = variationMatches.length;
-  let workingText = text;
-  const codeBlockMatches = text.match(/```[\s\S]*?```/g) || [];
-  let codeBlockTokens = 0;
-  for (const block of codeBlockMatches) {
-    const hasLang = /^```\w+/.test(block);
-    const overhead = hasLang ? 6 : 4;
-    const content = block.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
-    const contentNewlines = (content.match(/\n/g) || []).length;
-    const contentTokens = content.length > 0 ? content.length / 2.5 : 0;
-    codeBlockTokens += Math.max(
-      overhead,
-      overhead + contentNewlines + contentTokens
-    );
-    workingText = workingText.replace(block, "");
-  }
-  const inlineCodeMatches = workingText.match(/`[^`]+`/g) || [];
-  let inlineCodeTokens = 0;
-  for (const match of inlineCodeMatches) {
-    const content = match.slice(1, -1);
-    inlineCodeTokens += 2 + content.length / 2.5;
-    workingText = workingText.replace(match, "");
-  }
-  const pathMatches = workingText.match(/(?:\/[\w.-]+)+/g) || [];
-  let pathTokens = 0;
-  for (const match of pathMatches) {
-    const slashCount = (match.match(/\//g) || []).length;
-    const contentLength = match.length - slashCount;
-    pathTokens += slashCount + contentLength / 3.5;
-    workingText = workingText.replace(match, "");
-  }
-  const punctuationMatches = workingText.match(/[!?,.:;'"()[\]{}@#$%^&*+=|\\<>~\-/]/g) || [];
-  const punctuationCount = punctuationMatches.length;
-  const proseNewlines = (workingText.match(/\n/g) || []).length;
-  const proseLength = Math.max(
-    0,
-    workingText.length - proseNewlines - cjkCount - emojiCount - variationCount - punctuationCount
-  );
-  const proseTokens = proseLength / 3.5;
-  const proseNewlineTokens = proseNewlines * 1;
-  const punctuationBonus = punctuationCount * 0.8;
-  const cjkTokens = cjkCount * 1.2;
-  const emojiTokens = emojiCount * 2.5;
-  const variationTokens = variationCount * 1;
-  const estimate = proseTokens + proseNewlineTokens + codeBlockTokens + inlineCodeTokens + pathTokens + punctuationBonus + cjkTokens + emojiTokens + variationTokens;
-  return Math.ceil(estimate * 1.1);
+	if (text.length === 0) return 0;
+	const cjkPattern =
+		/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u3400-\u4dbf]/g;
+	const cjkMatches = text.match(cjkPattern) || [];
+	const cjkCount = cjkMatches.length;
+	const emojiPattern =
+		/[\u{1F300}-\u{1F9FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2300}-\u{23FF}\u{2190}-\u{21FF}\u{25A0}-\u{25FF}\u{2B00}-\u{2BFF}]/gu;
+	const emojiMatches = text.match(emojiPattern) || [];
+	const emojiCount = emojiMatches.length;
+	const variationSelectorPattern = /[\uFE0E\uFE0F]/g;
+	const variationMatches = text.match(variationSelectorPattern) || [];
+	const variationCount = variationMatches.length;
+	let workingText = text;
+	const codeBlockMatches = text.match(/```[\s\S]*?```/g) || [];
+	let codeBlockTokens = 0;
+	for (const block of codeBlockMatches) {
+		const hasLang = /^```\w+/.test(block);
+		const overhead = hasLang ? 6 : 4;
+		const content = block.replace(/^```\w*\n?/, "").replace(/\n?```$/, "");
+		const contentNewlines = (content.match(/\n/g) || []).length;
+		const contentTokens = content.length > 0 ? content.length / 2.5 : 0;
+		codeBlockTokens += Math.max(
+			overhead,
+			overhead + contentNewlines + contentTokens,
+		);
+		workingText = workingText.replace(block, "");
+	}
+	const inlineCodeMatches = workingText.match(/`[^`]+`/g) || [];
+	let inlineCodeTokens = 0;
+	for (const match of inlineCodeMatches) {
+		const content = match.slice(1, -1);
+		inlineCodeTokens += 2 + content.length / 2.5;
+		workingText = workingText.replace(match, "");
+	}
+	const pathMatches = workingText.match(/(?:\/[\w.-]+)+/g) || [];
+	let pathTokens = 0;
+	for (const match of pathMatches) {
+		const slashCount = (match.match(/\//g) || []).length;
+		const contentLength = match.length - slashCount;
+		pathTokens += slashCount + contentLength / 3.5;
+		workingText = workingText.replace(match, "");
+	}
+	const punctuationMatches =
+		workingText.match(/[!?,.:;'"()[\]{}@#$%^&*+=|\\<>~\-/]/g) || [];
+	const punctuationCount = punctuationMatches.length;
+	const proseNewlines = (workingText.match(/\n/g) || []).length;
+	const proseLength = Math.max(
+		0,
+		workingText.length -
+			proseNewlines -
+			cjkCount -
+			emojiCount -
+			variationCount -
+			punctuationCount,
+	);
+	const proseTokens = proseLength / 3.5;
+	const proseNewlineTokens = proseNewlines * 1;
+	const punctuationBonus = punctuationCount * 0.8;
+	const cjkTokens = cjkCount * 1.2;
+	const emojiTokens = emojiCount * 2.5;
+	const variationTokens = variationCount * 1;
+	const estimate =
+		proseTokens +
+		proseNewlineTokens +
+		codeBlockTokens +
+		inlineCodeTokens +
+		pathTokens +
+		punctuationBonus +
+		cjkTokens +
+		emojiTokens +
+		variationTokens;
+	return Math.ceil(estimate * 1.1);
 };
 var countWords = (text) => {
-  const trimmed = text.trim();
-  if (trimmed.length === 0) return 0;
-  return trimmed.split(/\s+/).length;
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return 0;
+	return trimmed.split(/\s+/).length;
 };
 var freeEncoder = () => {
-  if (encoder !== null) {
-    encoder.free();
-    encoder = null;
-  }
+	if (encoder !== null) {
+		encoder.free();
+		encoder = null;
+	}
 };
 
 // src/parser/parser.ts
@@ -90,653 +109,695 @@ import remarkGfm from "remark-gfm";
 import remarkParse from "remark-parse";
 import { unified } from "unified";
 import { visit } from "unist-util-visit";
+
 var processor = unified().use(remarkParse).use(remarkGfm);
 var generateId = (input) => {
-  return crypto.createHash("md5").update(input).digest("hex").slice(0, 12);
+	return crypto.createHash("md5").update(input).digest("hex").slice(0, 12);
 };
 var slugify = (text) => {
-  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+	return text
+		.toLowerCase()
+		.replace(/[^\w\s-]/g, "")
+		.replace(/\s+/g, "-")
+		.replace(/-+/g, "-")
+		.trim();
 };
 var isInternalLink = (href) => {
-  if (href.startsWith("http://") || href.startsWith("https://")) return false;
-  if (href.startsWith("mailto:")) return false;
-  if (href.startsWith("#")) return true;
-  if (href.endsWith(".md") || href.includes(".md#")) return true;
-  return !href.includes("://");
+	if (href.startsWith("http://") || href.startsWith("https://")) return false;
+	if (href.startsWith("mailto:")) return false;
+	if (href.startsWith("#")) return true;
+	if (href.endsWith(".md") || href.includes(".md#")) return true;
+	return !href.includes("://");
 };
 var extractPlainText = (node) => {
-  const texts = [];
-  visit(node, "text", (textNode) => {
-    texts.push(textNode.value);
-  });
-  return texts.join(" ");
+	const texts = [];
+	visit(node, "text", (textNode) => {
+		texts.push(textNode.value);
+	});
+	return texts.join(" ");
 };
 var getNodeEndLine = (node) => {
-  return node?.position?.end?.line ?? 0;
+	return node?.position?.end?.line ?? 0;
 };
 var getNodeStartLine = (node) => {
-  return node?.position?.start?.line ?? 0;
+	return node?.position?.start?.line ?? 0;
 };
 var extractRawSections = (tree) => {
-  const sections = [];
-  const headings = [];
-  tree.children.forEach((node, index) => {
-    if (node.type === "heading") {
-      const heading = node;
-      headings.push({
-        heading: extractPlainText(heading),
-        level: heading.depth,
-        line: getNodeStartLine(node),
-        index
-      });
-    }
-  });
-  headings.forEach((h, i) => {
-    const nextHeading = headings[i + 1];
-    const endIndex = nextHeading ? nextHeading.index : tree.children.length;
-    const contentNodes = tree.children.slice(h.index + 1, endIndex);
-    const lastContentNode = contentNodes[contentNodes.length - 1];
-    const endLine = lastContentNode ? getNodeEndLine(lastContentNode) : h.line;
-    sections.push({
-      heading: h.heading,
-      level: h.level,
-      startLine: h.line,
-      endLine,
-      contentStartLine: h.line + 1,
-      contentNodes
-    });
-  });
-  return sections;
+	const sections = [];
+	const headings = [];
+	tree.children.forEach((node, index) => {
+		if (node.type === "heading") {
+			const heading = node;
+			headings.push({
+				heading: extractPlainText(heading),
+				level: heading.depth,
+				line: getNodeStartLine(node),
+				index,
+			});
+		}
+	});
+	headings.forEach((h, i) => {
+		const nextHeading = headings[i + 1];
+		const endIndex = nextHeading ? nextHeading.index : tree.children.length;
+		const contentNodes = tree.children.slice(h.index + 1, endIndex);
+		const lastContentNode = contentNodes[contentNodes.length - 1];
+		const endLine = lastContentNode ? getNodeEndLine(lastContentNode) : h.line;
+		sections.push({
+			heading: h.heading,
+			level: h.level,
+			startLine: h.line,
+			endLine,
+			contentStartLine: h.line + 1,
+			contentNodes,
+		});
+	});
+	return sections;
 };
 var buildSectionHierarchy = (rawSections, docId, lines) => {
-  const result = [];
-  const stack = [];
-  for (const raw of rawSections) {
-    const contentLines = lines.slice(raw.startLine - 1, raw.endLine);
-    const content = contentLines.join("\n");
-    const plainText = extractSectionPlainText(raw.contentNodes);
-    const hasCode = raw.contentNodes.some(
-      (n) => n.type === "code"
-    );
-    const hasList = raw.contentNodes.some(
-      (n) => n.type === "list"
-    );
-    const hasTable = raw.contentNodes.some(
-      (n) => n.type === "table"
-    );
-    const section = {
-      id: `${docId}-${slugify(raw.heading)}`,
-      heading: raw.heading,
-      level: raw.level,
-      content,
-      plainText,
-      startLine: raw.startLine,
-      endLine: raw.endLine,
-      children: [],
-      metadata: {
-        wordCount: countWords(plainText),
-        tokenCount: countTokensApprox(content),
-        hasCode,
-        hasList,
-        hasTable
-      }
-    };
-    while (stack.length > 0 && stack[stack.length - 1].level >= raw.level) {
-      stack.pop();
-    }
-    if (stack.length === 0) {
-      result.push(section);
-    } else {
-      const parent = stack[stack.length - 1];
-      parent.section.children.push(section);
-    }
-    stack.push({ section, level: raw.level });
-  }
-  return result;
+	const result = [];
+	const stack = [];
+	for (const raw of rawSections) {
+		const contentLines = lines.slice(raw.startLine - 1, raw.endLine);
+		const content = contentLines.join("\n");
+		const plainText = extractSectionPlainText(raw.contentNodes);
+		const hasCode = raw.contentNodes.some((n) => n.type === "code");
+		const hasList = raw.contentNodes.some((n) => n.type === "list");
+		const hasTable = raw.contentNodes.some((n) => n.type === "table");
+		const section = {
+			id: `${docId}-${slugify(raw.heading)}`,
+			heading: raw.heading,
+			level: raw.level,
+			content,
+			plainText,
+			startLine: raw.startLine,
+			endLine: raw.endLine,
+			children: [],
+			metadata: {
+				wordCount: countWords(plainText),
+				tokenCount: countTokensApprox(content),
+				hasCode,
+				hasList,
+				hasTable,
+			},
+		};
+		while (stack.length > 0 && stack[stack.length - 1].level >= raw.level) {
+			stack.pop();
+		}
+		if (stack.length === 0) {
+			result.push(section);
+		} else {
+			const parent = stack[stack.length - 1];
+			parent.section.children.push(section);
+		}
+		stack.push({ section, level: raw.level });
+	}
+	return result;
 };
 var extractSectionPlainText = (nodes) => {
-  const texts = [];
-  for (const node of nodes) {
-    if ("value" in node && typeof node.value === "string") {
-      texts.push(node.value);
-    } else if ("children" in node) {
-      texts.push(extractPlainText(node));
-    }
-  }
-  return texts.join(" ");
+	const texts = [];
+	for (const node of nodes) {
+		if ("value" in node && typeof node.value === "string") {
+			texts.push(node.value);
+		} else if ("children" in node) {
+			texts.push(extractPlainText(node));
+		}
+	}
+	return texts.join(" ");
 };
 var countAllSections = (sections) => {
-  let count = 0;
-  for (const section of sections) {
-    count += 1;
-    count += countAllSections(section.children);
-  }
-  return count;
+	let count = 0;
+	for (const section of sections) {
+		count += 1;
+		count += countAllSections(section.children);
+	}
+	return count;
 };
 var extractLinks = (tree, docId) => {
-  const links = [];
-  let currentSectionId = docId;
-  visit(tree, (node) => {
-    if (node.type === "heading") {
-      currentSectionId = `${docId}-${slugify(extractPlainText(node))}`;
-    }
-    if (node.type === "link") {
-      const link = node;
-      const internal = isInternalLink(link.url);
-      links.push({
-        type: internal ? "internal" : "external",
-        href: link.url,
-        text: extractPlainText(link),
-        sectionId: currentSectionId,
-        line: getNodeStartLine(node)
-      });
-    }
-    if (node.type === "image") {
-      const img = node;
-      links.push({
-        type: "image",
-        href: img.url,
-        text: img.alt ?? "",
-        sectionId: currentSectionId,
-        line: getNodeStartLine(node)
-      });
-    }
-  });
-  return links;
+	const links = [];
+	let currentSectionId = docId;
+	visit(tree, (node) => {
+		if (node.type === "heading") {
+			currentSectionId = `${docId}-${slugify(extractPlainText(node))}`;
+		}
+		if (node.type === "link") {
+			const link = node;
+			const internal = isInternalLink(link.url);
+			links.push({
+				type: internal ? "internal" : "external",
+				href: link.url,
+				text: extractPlainText(link),
+				sectionId: currentSectionId,
+				line: getNodeStartLine(node),
+			});
+		}
+		if (node.type === "image") {
+			const img = node;
+			links.push({
+				type: "image",
+				href: img.url,
+				text: img.alt ?? "",
+				sectionId: currentSectionId,
+				line: getNodeStartLine(node),
+			});
+		}
+	});
+	return links;
 };
 var extractCodeBlocks = (tree, docId) => {
-  const codeBlocks = [];
-  let currentSectionId = docId;
-  visit(tree, (node) => {
-    if (node.type === "heading") {
-      currentSectionId = `${docId}-${slugify(extractPlainText(node))}`;
-    }
-    if (node.type === "code") {
-      const code = node;
-      codeBlocks.push({
-        language: code.lang ?? null,
-        content: code.value,
-        sectionId: currentSectionId,
-        startLine: getNodeStartLine(node),
-        endLine: getNodeEndLine(node)
-      });
-    }
-  });
-  return codeBlocks;
+	const codeBlocks = [];
+	let currentSectionId = docId;
+	visit(tree, (node) => {
+		if (node.type === "heading") {
+			currentSectionId = `${docId}-${slugify(extractPlainText(node))}`;
+		}
+		if (node.type === "code") {
+			const code = node;
+			codeBlocks.push({
+				language: code.lang ?? null,
+				content: code.value,
+				sectionId: currentSectionId,
+				startLine: getNodeStartLine(node),
+				endLine: getNodeEndLine(node),
+			});
+		}
+	});
+	return codeBlocks;
 };
-var parse = (content, options = {}) => Effect2.gen(function* () {
-  const path3 = options.path ?? "unknown";
-  const docId = generateId(path3);
-  const now = /* @__PURE__ */ new Date();
-  let frontmatter = {};
-  let markdownContent = content;
-  try {
-    const parsed = matter(content);
-    frontmatter = parsed.data;
-    markdownContent = parsed.content;
-  } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.warn(
-      `Warning: Malformed frontmatter in ${path3}, skipping: ${msg.split("\n")[0]}`
-    );
-  }
-  const tree = processor.parse(markdownContent);
-  const lines = markdownContent.split("\n");
-  const rawSections = extractRawSections(tree);
-  const sections = buildSectionHierarchy(rawSections, docId, lines);
-  const links = extractLinks(tree, docId);
-  const codeBlocks = extractCodeBlocks(tree, docId);
-  const firstH1 = sections.find((s) => s.level === 1);
-  const title = firstH1?.heading ?? (typeof frontmatter.title === "string" ? frontmatter.title : null) ?? path3.split("/").pop()?.replace(/\.md$/, "") ?? "Untitled";
-  const totalContent = sections.map((s) => s.content).join("\n");
-  const metadata = {
-    wordCount: countWords(totalContent),
-    tokenCount: countTokensApprox(content),
-    headingCount: countAllSections(sections),
-    linkCount: links.length,
-    codeBlockCount: codeBlocks.length,
-    lastModified: options.lastModified ?? now,
-    indexedAt: now
-  };
-  const document = {
-    id: docId,
-    path: path3,
-    title,
-    frontmatter,
-    sections,
-    links,
-    codeBlocks,
-    metadata
-  };
-  return document;
-});
-var parseFile = (filePath) => Effect2.gen(function* () {
-  const fs3 = yield* Effect2.promise(() => import("fs/promises"));
-  let content;
-  let stats;
-  try {
-    ;
-    [content, stats] = yield* Effect2.all([
-      Effect2.promise(() => fs3.readFile(filePath, "utf-8")),
-      Effect2.promise(() => fs3.stat(filePath))
-    ]);
-  } catch (error) {
-    return yield* Effect2.fail({
-      _tag: "IoError",
-      message: error instanceof Error ? error.message : "Unknown error",
-      path: filePath
-    });
-  }
-  return yield* parse(content, {
-    path: filePath,
-    lastModified: stats.mtime
-  });
-});
+var parse = (content, options = {}) =>
+	Effect2.gen(function* () {
+		const path3 = options.path ?? "unknown";
+		const docId = generateId(path3);
+		const now = /* @__PURE__ */ new Date();
+		let frontmatter = {};
+		let markdownContent = content;
+		try {
+			const parsed = matter(content);
+			frontmatter = parsed.data;
+			markdownContent = parsed.content;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			console.warn(
+				`Warning: Malformed frontmatter in ${path3}, skipping: ${msg.split("\n")[0]}`,
+			);
+		}
+		const tree = processor.parse(markdownContent);
+		const lines = markdownContent.split("\n");
+		const rawSections = extractRawSections(tree);
+		const sections = buildSectionHierarchy(rawSections, docId, lines);
+		const links = extractLinks(tree, docId);
+		const codeBlocks = extractCodeBlocks(tree, docId);
+		const firstH1 = sections.find((s) => s.level === 1);
+		const title =
+			firstH1?.heading ??
+			(typeof frontmatter.title === "string" ? frontmatter.title : null) ??
+			path3.split("/").pop()?.replace(/\.md$/, "") ??
+			"Untitled";
+		const totalContent = sections.map((s) => s.content).join("\n");
+		const metadata = {
+			wordCount: countWords(totalContent),
+			tokenCount: countTokensApprox(content),
+			headingCount: countAllSections(sections),
+			linkCount: links.length,
+			codeBlockCount: codeBlocks.length,
+			lastModified: options.lastModified ?? now,
+			indexedAt: now,
+		};
+		const document = {
+			id: docId,
+			path: path3,
+			title,
+			frontmatter,
+			sections,
+			links,
+			codeBlocks,
+			metadata,
+		};
+		return document;
+	});
+var parseFile = (filePath) =>
+	Effect2.gen(function* () {
+		const fs3 = yield* Effect2.promise(() => import("fs/promises"));
+		let content;
+		let stats;
+		try {
+			[content, stats] = yield* Effect2.all([
+				Effect2.promise(() => fs3.readFile(filePath, "utf-8")),
+				Effect2.promise(() => fs3.stat(filePath)),
+			]);
+		} catch (error) {
+			return yield* Effect2.fail({
+				_tag: "IoError",
+				message: error instanceof Error ? error.message : "Unknown error",
+				path: filePath,
+			});
+		}
+		return yield* parse(content, {
+			path: filePath,
+			lastModified: stats.mtime,
+		});
+	});
 
 // src/index/types.ts
 var INDEX_DIR = ".mdcontext";
 var INDEX_VERSION = 1;
 var getIndexPaths = (rootPath) => ({
-  root: `${rootPath}/${INDEX_DIR}`,
-  config: `${rootPath}/${INDEX_DIR}/config.json`,
-  documents: `${rootPath}/${INDEX_DIR}/indexes/documents.json`,
-  sections: `${rootPath}/${INDEX_DIR}/indexes/sections.json`,
-  links: `${rootPath}/${INDEX_DIR}/indexes/links.json`,
-  cache: `${rootPath}/${INDEX_DIR}/cache`,
-  parsed: `${rootPath}/${INDEX_DIR}/cache/parsed`
+	root: `${rootPath}/${INDEX_DIR}`,
+	config: `${rootPath}/${INDEX_DIR}/config.json`,
+	documents: `${rootPath}/${INDEX_DIR}/indexes/documents.json`,
+	sections: `${rootPath}/${INDEX_DIR}/indexes/sections.json`,
+	links: `${rootPath}/${INDEX_DIR}/indexes/links.json`,
+	cache: `${rootPath}/${INDEX_DIR}/cache`,
+	parsed: `${rootPath}/${INDEX_DIR}/cache/parsed`,
 });
 
 // src/index/storage.ts
 import * as crypto2 from "crypto";
+import { Effect as Effect3 } from "effect";
 import * as fs from "fs/promises";
 import * as path from "path";
-import { Effect as Effect3 } from "effect";
-var ensureDir = (dirPath) => Effect3.tryPromise({
-  try: () => fs.mkdir(dirPath, { recursive: true }),
-  catch: (e) => new Error(`Failed to create directory ${dirPath}: ${e}`)
-}).pipe(Effect3.map(() => void 0));
-var readJsonFile = (filePath) => Effect3.tryPromise({
-  try: async () => {
-    try {
-      const content = await fs.readFile(filePath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  },
-  catch: (e) => new Error(`Failed to read ${filePath}: ${e}`)
-});
-var writeJsonFile = (filePath, data) => Effect3.gen(function* () {
-  const dir = path.dirname(filePath);
-  yield* ensureDir(dir);
-  yield* Effect3.tryPromise({
-    try: () => fs.writeFile(filePath, JSON.stringify(data, null, 2)),
-    catch: (e) => new Error(`Failed to write ${filePath}: ${e}`)
-  });
-});
+
+var ensureDir = (dirPath) =>
+	Effect3.tryPromise({
+		try: () => fs.mkdir(dirPath, { recursive: true }),
+		catch: (e) => new Error(`Failed to create directory ${dirPath}: ${e}`),
+	}).pipe(Effect3.map(() => void 0));
+var readJsonFile = (filePath) =>
+	Effect3.tryPromise({
+		try: async () => {
+			try {
+				const content = await fs.readFile(filePath, "utf-8");
+				return JSON.parse(content);
+			} catch {
+				return null;
+			}
+		},
+		catch: (e) => new Error(`Failed to read ${filePath}: ${e}`),
+	});
+var writeJsonFile = (filePath, data) =>
+	Effect3.gen(function* () {
+		const dir = path.dirname(filePath);
+		yield* ensureDir(dir);
+		yield* Effect3.tryPromise({
+			try: () => fs.writeFile(filePath, JSON.stringify(data, null, 2)),
+			catch: (e) => new Error(`Failed to write ${filePath}: ${e}`),
+		});
+	});
 var computeHash = (content) => {
-  return crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+	return crypto2
+		.createHash("sha256")
+		.update(content)
+		.digest("hex")
+		.slice(0, 16);
 };
 var createStorage = (rootPath) => ({
-  rootPath: path.resolve(rootPath),
-  paths: getIndexPaths(path.resolve(rootPath))
-});
-var initializeIndex = (storage) => Effect3.gen(function* () {
-  yield* ensureDir(storage.paths.root);
-  yield* ensureDir(storage.paths.parsed);
-  yield* ensureDir(path.dirname(storage.paths.documents));
-  const existingConfig = yield* loadConfig(storage);
-  if (!existingConfig) {
-    const config = {
-      version: INDEX_VERSION,
-      rootPath: storage.rootPath,
-      include: ["**/*.md", "**/*.mdx"],
-      exclude: ["**/node_modules/**", "**/.*/**"],
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    yield* saveConfig(storage, config);
-  }
+	rootPath: path.resolve(rootPath),
+	paths: getIndexPaths(path.resolve(rootPath)),
 });
+var initializeIndex = (storage) =>
+	Effect3.gen(function* () {
+		yield* ensureDir(storage.paths.root);
+		yield* ensureDir(storage.paths.parsed);
+		yield* ensureDir(path.dirname(storage.paths.documents));
+		const existingConfig = yield* loadConfig(storage);
+		if (!existingConfig) {
+			const config = {
+				version: INDEX_VERSION,
+				rootPath: storage.rootPath,
+				include: ["**/*.md", "**/*.mdx"],
+				exclude: ["**/node_modules/**", "**/.*/**"],
+				createdAt: /* @__PURE__ */ new Date().toISOString(),
+				updatedAt: /* @__PURE__ */ new Date().toISOString(),
+			};
+			yield* saveConfig(storage, config);
+		}
+	});
 var loadConfig = (storage) => readJsonFile(storage.paths.config);
-var saveConfig = (storage, config) => writeJsonFile(storage.paths.config, {
-  ...config,
-  updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-});
+var saveConfig = (storage, config) =>
+	writeJsonFile(storage.paths.config, {
+		...config,
+		updatedAt: /* @__PURE__ */ new Date().toISOString(),
+	});
 var loadDocumentIndex = (storage) => readJsonFile(storage.paths.documents);
-var saveDocumentIndex = (storage, index) => writeJsonFile(storage.paths.documents, index);
+var saveDocumentIndex = (storage, index) =>
+	writeJsonFile(storage.paths.documents, index);
 var createEmptyDocumentIndex = (rootPath) => ({
-  version: INDEX_VERSION,
-  rootPath,
-  documents: {}
+	version: INDEX_VERSION,
+	rootPath,
+	documents: {},
 });
 var loadSectionIndex = (storage) => readJsonFile(storage.paths.sections);
-var saveSectionIndex = (storage, index) => writeJsonFile(storage.paths.sections, index);
+var saveSectionIndex = (storage, index) =>
+	writeJsonFile(storage.paths.sections, index);
 var createEmptySectionIndex = () => ({
-  version: INDEX_VERSION,
-  sections: {},
-  byHeading: {},
-  byDocument: {}
+	version: INDEX_VERSION,
+	sections: {},
+	byHeading: {},
+	byDocument: {},
 });
 var loadLinkIndex = (storage) => readJsonFile(storage.paths.links);
-var saveLinkIndex = (storage, index) => writeJsonFile(storage.paths.links, index);
+var saveLinkIndex = (storage, index) =>
+	writeJsonFile(storage.paths.links, index);
 var createEmptyLinkIndex = () => ({
-  version: INDEX_VERSION,
-  forward: {},
-  backward: {},
-  broken: []
-});
-var indexExists = (storage) => Effect3.tryPromise({
-  try: async () => {
-    try {
-      await fs.access(storage.paths.config);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  catch: (e) => new Error(`Failed to check index existence: ${e}`)
+	version: INDEX_VERSION,
+	forward: {},
+	backward: {},
+	broken: [],
 });
+var indexExists = (storage) =>
+	Effect3.tryPromise({
+		try: async () => {
+			try {
+				await fs.access(storage.paths.config);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		catch: (e) => new Error(`Failed to check index existence: ${e}`),
+	});
 
+import { Effect as Effect4 } from "effect";
 // src/index/indexer.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
-import { Effect as Effect4 } from "effect";
-var isMarkdownFile = (filename) => filename.endsWith(".md") || filename.endsWith(".mdx");
+
+var isMarkdownFile = (filename) =>
+	filename.endsWith(".md") || filename.endsWith(".mdx");
 var shouldExclude = (filePath, exclude) => {
-  const normalized = filePath.toLowerCase();
-  for (const pattern of exclude) {
-    if (pattern.includes("node_modules") && normalized.includes("node_modules")) {
-      return true;
-    }
-    if (pattern.startsWith("**/.*") && normalized.includes("/.")) {
-      return true;
-    }
-  }
-  return false;
+	const normalized = filePath.toLowerCase();
+	for (const pattern of exclude) {
+		if (
+			pattern.includes("node_modules") &&
+			normalized.includes("node_modules")
+		) {
+			return true;
+		}
+		if (pattern.startsWith("**/.*") && normalized.includes("/.")) {
+			return true;
+		}
+	}
+	return false;
 };
 var walkDirectory = async (dir, exclude) => {
-  const files = [];
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    if (entry.name.startsWith(".") || entry.name === "node_modules") {
-      continue;
-    }
-    if (shouldExclude(fullPath, exclude)) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      const subFiles = await walkDirectory(fullPath, exclude);
-      files.push(...subFiles);
-    } else if (entry.isFile() && isMarkdownFile(entry.name)) {
-      files.push(fullPath);
-    }
-  }
-  return files;
+	const files = [];
+	const entries = await fs2.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path2.join(dir, entry.name);
+		if (entry.name.startsWith(".") || entry.name === "node_modules") {
+			continue;
+		}
+		if (shouldExclude(fullPath, exclude)) {
+			continue;
+		}
+		if (entry.isDirectory()) {
+			const subFiles = await walkDirectory(fullPath, exclude);
+			files.push(...subFiles);
+		} else if (entry.isFile() && isMarkdownFile(entry.name)) {
+			files.push(fullPath);
+		}
+	}
+	return files;
 };
 var flattenSections = (sections, docId, docPath) => {
-  const result = [];
-  const traverse = (section) => {
-    result.push({
-      id: section.id,
-      documentId: docId,
-      documentPath: docPath,
-      heading: section.heading,
-      level: section.level,
-      startLine: section.startLine,
-      endLine: section.endLine,
-      tokenCount: section.metadata.tokenCount,
-      hasCode: section.metadata.hasCode,
-      hasList: section.metadata.hasList,
-      hasTable: section.metadata.hasTable
-    });
-    for (const child of section.children) {
-      traverse(child);
-    }
-  };
-  for (const section of sections) {
-    traverse(section);
-  }
-  return result;
+	const result = [];
+	const traverse = (section) => {
+		result.push({
+			id: section.id,
+			documentId: docId,
+			documentPath: docPath,
+			heading: section.heading,
+			level: section.level,
+			startLine: section.startLine,
+			endLine: section.endLine,
+			tokenCount: section.metadata.tokenCount,
+			hasCode: section.metadata.hasCode,
+			hasList: section.metadata.hasList,
+			hasTable: section.metadata.hasTable,
+		});
+		for (const child of section.children) {
+			traverse(child);
+		}
+	};
+	for (const section of sections) {
+		traverse(section);
+	}
+	return result;
 };
 var resolveInternalLink = (href, fromPath, rootPath) => {
-  if (href.startsWith("#")) {
-    return fromPath;
-  }
-  if (href.startsWith("http://") || href.startsWith("https://")) {
-    return null;
-  }
-  const linkPath = href.split("#")[0] ?? "";
-  if (!linkPath) return null;
-  const fromDir = path2.dirname(fromPath);
-  const resolved = path2.resolve(fromDir, linkPath);
-  if (!resolved.startsWith(rootPath)) {
-    return null;
-  }
-  return path2.relative(rootPath, resolved);
+	if (href.startsWith("#")) {
+		return fromPath;
+	}
+	if (href.startsWith("http://") || href.startsWith("https://")) {
+		return null;
+	}
+	const linkPath = href.split("#")[0] ?? "";
+	if (!linkPath) return null;
+	const fromDir = path2.dirname(fromPath);
+	const resolved = path2.resolve(fromDir, linkPath);
+	if (!resolved.startsWith(rootPath)) {
+		return null;
+	}
+	return path2.relative(rootPath, resolved);
 };
-var buildIndex = (rootPath, options = {}) => Effect4.gen(function* () {
-  const startTime = Date.now();
-  const storage = createStorage(rootPath);
-  const errors = [];
-  yield* initializeIndex(storage);
-  const existingDocIndex = yield* loadDocumentIndex(storage);
-  const docIndex = options.force || !existingDocIndex ? createEmptyDocumentIndex(storage.rootPath) : existingDocIndex;
-  const existingSectionIndex = yield* loadSectionIndex(storage);
-  const existingLinkIndex = yield* loadLinkIndex(storage);
-  const sectionIndex = existingSectionIndex ?? createEmptySectionIndex();
-  const linkIndex = existingLinkIndex ?? createEmptyLinkIndex();
-  const exclude = options.exclude ?? ["**/node_modules/**", "**/.*/**"];
-  const files = yield* Effect4.tryPromise({
-    try: () => walkDirectory(storage.rootPath, exclude),
-    catch: (e) => new Error(`Failed to walk directory: ${e}`)
-  });
-  let documentsIndexed = 0;
-  let sectionsIndexed = 0;
-  let linksIndexed = 0;
-  const mutableDocuments = {
-    ...docIndex.documents
-  };
-  const mutableSections = {
-    ...sectionIndex.sections
-  };
-  const mutableByHeading = Object.fromEntries(
-    Object.entries(sectionIndex.byHeading).map(([k, v]) => [k, [...v]])
-  );
-  const mutableByDocument = Object.fromEntries(
-    Object.entries(sectionIndex.byDocument).map(([k, v]) => [k, [...v]])
-  );
-  const mutableForward = Object.fromEntries(
-    Object.entries(linkIndex.forward).map(([k, v]) => [k, [...v]])
-  );
-  const mutableBackward = Object.fromEntries(
-    Object.entries(linkIndex.backward).map(([k, v]) => [k, [...v]])
-  );
-  const brokenLinks = [...linkIndex.broken];
-  for (const filePath of files) {
-    const relativePath = path2.relative(storage.rootPath, filePath);
-    const processFile = Effect4.gen(function* () {
-      const [content, stats] = yield* Effect4.promise(
-        () => Promise.all([fs2.readFile(filePath, "utf-8"), fs2.stat(filePath)])
-      );
-      const hash = computeHash(content);
-      const existingEntry = mutableDocuments[relativePath];
-      if (!options.force && existingEntry && existingEntry.hash === hash && existingEntry.mtime === stats.mtime.getTime()) {
-        return;
-      }
-      const doc = yield* parse(content, {
-        path: relativePath,
-        lastModified: stats.mtime
-      }).pipe(
-        Effect4.mapError(
-          (e) => new Error(`Parse error in ${relativePath}: ${e.message}`)
-        )
-      );
-      if (existingEntry) {
-        const oldSectionIds = mutableByDocument[existingEntry.id] ?? [];
-        for (const sectionId of oldSectionIds) {
-          const oldSection = mutableSections[sectionId];
-          if (oldSection) {
-            const headingKey = oldSection.heading.toLowerCase();
-            const headingList = mutableByHeading[headingKey];
-            if (headingList) {
-              const idx = headingList.indexOf(sectionId);
-              if (idx !== -1) headingList.splice(idx, 1);
-            }
-          }
-          delete mutableSections[sectionId];
-        }
-        delete mutableByDocument[existingEntry.id];
-        delete mutableForward[relativePath];
-      }
-      mutableDocuments[relativePath] = {
-        id: doc.id,
-        path: relativePath,
-        title: doc.title,
-        mtime: stats.mtime.getTime(),
-        hash,
-        tokenCount: doc.metadata.tokenCount,
-        sectionCount: doc.metadata.headingCount
-      };
-      documentsIndexed++;
-      const sections = flattenSections(doc.sections, doc.id, relativePath);
-      mutableByDocument[doc.id] = [];
-      for (const section of sections) {
-        mutableSections[section.id] = section;
-        mutableByDocument[doc.id]?.push(section.id);
-        const headingKey = section.heading.toLowerCase();
-        if (!mutableByHeading[headingKey]) {
-          mutableByHeading[headingKey] = [];
-        }
-        mutableByHeading[headingKey]?.push(section.id);
-        sectionsIndexed++;
-      }
-      const internalLinks = doc.links.filter((l) => l.type === "internal");
-      const outgoingLinks = [];
-      for (const link of internalLinks) {
-        const target = resolveInternalLink(
-          link.href,
-          filePath,
-          storage.rootPath
-        );
-        if (target) {
-          outgoingLinks.push(target);
-          if (!mutableBackward[target]) {
-            mutableBackward[target] = [];
-          }
-          if (!mutableBackward[target]?.includes(relativePath)) {
-            mutableBackward[target]?.push(relativePath);
-          }
-          linksIndexed++;
-        }
-      }
-      mutableForward[relativePath] = outgoingLinks;
-    }).pipe(
-      Effect4.catchAll((error) => {
-        errors.push({
-          path: relativePath,
-          message: error instanceof Error ? error.message : String(error)
-        });
-        return Effect4.void;
-      })
-    );
-    yield* processFile;
-  }
-  for (const [_from, targets] of Object.entries(mutableForward)) {
-    for (const target of targets) {
-      if (!mutableDocuments[target] && !brokenLinks.includes(target)) {
-        brokenLinks.push(target);
-      }
-    }
-  }
-  yield* saveDocumentIndex(storage, {
-    version: docIndex.version,
-    rootPath: storage.rootPath,
-    documents: mutableDocuments
-  });
-  yield* saveSectionIndex(storage, {
-    version: sectionIndex.version,
-    sections: mutableSections,
-    byHeading: mutableByHeading,
-    byDocument: mutableByDocument
-  });
-  yield* saveLinkIndex(storage, {
-    version: linkIndex.version,
-    forward: mutableForward,
-    backward: mutableBackward,
-    broken: brokenLinks
-  });
-  const duration = Date.now() - startTime;
-  const totalLinks = Object.values(mutableForward).reduce(
-    (sum, links) => sum + links.length,
-    0
-  );
-  return {
-    documentsIndexed,
-    sectionsIndexed,
-    linksIndexed,
-    totalDocuments: Object.keys(mutableDocuments).length,
-    totalSections: Object.keys(mutableSections).length,
-    totalLinks,
-    duration,
-    errors
-  };
-});
-var getOutgoingLinks = (rootPath, filePath) => Effect4.gen(function* () {
-  const storage = createStorage(rootPath);
-  const linkIndex = yield* loadLinkIndex(storage);
-  if (!linkIndex) {
-    return [];
-  }
-  const relativePath = path2.relative(storage.rootPath, path2.resolve(filePath));
-  return linkIndex.forward[relativePath] ?? [];
-});
-var getIncomingLinks = (rootPath, filePath) => Effect4.gen(function* () {
-  const storage = createStorage(rootPath);
-  const linkIndex = yield* loadLinkIndex(storage);
-  if (!linkIndex) {
-    return [];
-  }
-  const relativePath = path2.relative(storage.rootPath, path2.resolve(filePath));
-  return linkIndex.backward[relativePath] ?? [];
-});
-var getBrokenLinks = (rootPath) => Effect4.gen(function* () {
-  const storage = createStorage(rootPath);
-  const linkIndex = yield* loadLinkIndex(storage);
-  if (!linkIndex) {
-    return [];
-  }
-  return linkIndex.broken;
-});
+var buildIndex = (rootPath, options = {}) =>
+	Effect4.gen(function* () {
+		const startTime = Date.now();
+		const storage = createStorage(rootPath);
+		const errors = [];
+		yield* initializeIndex(storage);
+		const existingDocIndex = yield* loadDocumentIndex(storage);
+		const docIndex =
+			options.force || !existingDocIndex
+				? createEmptyDocumentIndex(storage.rootPath)
+				: existingDocIndex;
+		const existingSectionIndex = yield* loadSectionIndex(storage);
+		const existingLinkIndex = yield* loadLinkIndex(storage);
+		const sectionIndex = existingSectionIndex ?? createEmptySectionIndex();
+		const linkIndex = existingLinkIndex ?? createEmptyLinkIndex();
+		const exclude = options.exclude ?? ["**/node_modules/**", "**/.*/**"];
+		const files = yield* Effect4.tryPromise({
+			try: () => walkDirectory(storage.rootPath, exclude),
+			catch: (e) => new Error(`Failed to walk directory: ${e}`),
+		});
+		let documentsIndexed = 0;
+		let sectionsIndexed = 0;
+		let linksIndexed = 0;
+		const mutableDocuments = {
+			...docIndex.documents,
+		};
+		const mutableSections = {
+			...sectionIndex.sections,
+		};
+		const mutableByHeading = Object.fromEntries(
+			Object.entries(sectionIndex.byHeading).map(([k, v]) => [k, [...v]]),
+		);
+		const mutableByDocument = Object.fromEntries(
+			Object.entries(sectionIndex.byDocument).map(([k, v]) => [k, [...v]]),
+		);
+		const mutableForward = Object.fromEntries(
+			Object.entries(linkIndex.forward).map(([k, v]) => [k, [...v]]),
+		);
+		const mutableBackward = Object.fromEntries(
+			Object.entries(linkIndex.backward).map(([k, v]) => [k, [...v]]),
+		);
+		const brokenLinks = [...linkIndex.broken];
+		for (const filePath of files) {
+			const relativePath = path2.relative(storage.rootPath, filePath);
+			const processFile = Effect4.gen(function* () {
+				const [content, stats] = yield* Effect4.promise(() =>
+					Promise.all([fs2.readFile(filePath, "utf-8"), fs2.stat(filePath)]),
+				);
+				const hash = computeHash(content);
+				const existingEntry = mutableDocuments[relativePath];
+				if (
+					!options.force &&
+					existingEntry &&
+					existingEntry.hash === hash &&
+					existingEntry.mtime === stats.mtime.getTime()
+				) {
+					return;
+				}
+				const doc = yield* parse(content, {
+					path: relativePath,
+					lastModified: stats.mtime,
+				}).pipe(
+					Effect4.mapError(
+						(e) => new Error(`Parse error in ${relativePath}: ${e.message}`),
+					),
+				);
+				if (existingEntry) {
+					const oldSectionIds = mutableByDocument[existingEntry.id] ?? [];
+					for (const sectionId of oldSectionIds) {
+						const oldSection = mutableSections[sectionId];
+						if (oldSection) {
+							const headingKey = oldSection.heading.toLowerCase();
+							const headingList = mutableByHeading[headingKey];
+							if (headingList) {
+								const idx = headingList.indexOf(sectionId);
+								if (idx !== -1) headingList.splice(idx, 1);
+							}
+						}
+						delete mutableSections[sectionId];
+					}
+					delete mutableByDocument[existingEntry.id];
+					delete mutableForward[relativePath];
+				}
+				mutableDocuments[relativePath] = {
+					id: doc.id,
+					path: relativePath,
+					title: doc.title,
+					mtime: stats.mtime.getTime(),
+					hash,
+					tokenCount: doc.metadata.tokenCount,
+					sectionCount: doc.metadata.headingCount,
+				};
+				documentsIndexed++;
+				const sections = flattenSections(doc.sections, doc.id, relativePath);
+				mutableByDocument[doc.id] = [];
+				for (const section of sections) {
+					mutableSections[section.id] = section;
+					mutableByDocument[doc.id]?.push(section.id);
+					const headingKey = section.heading.toLowerCase();
+					if (!mutableByHeading[headingKey]) {
+						mutableByHeading[headingKey] = [];
+					}
+					mutableByHeading[headingKey]?.push(section.id);
+					sectionsIndexed++;
+				}
+				const internalLinks = doc.links.filter((l) => l.type === "internal");
+				const outgoingLinks = [];
+				for (const link of internalLinks) {
+					const target = resolveInternalLink(
+						link.href,
+						filePath,
+						storage.rootPath,
+					);
+					if (target) {
+						outgoingLinks.push(target);
+						if (!mutableBackward[target]) {
+							mutableBackward[target] = [];
+						}
+						if (!mutableBackward[target]?.includes(relativePath)) {
+							mutableBackward[target]?.push(relativePath);
+						}
+						linksIndexed++;
+					}
+				}
+				mutableForward[relativePath] = outgoingLinks;
+			}).pipe(
+				Effect4.catchAll((error) => {
+					errors.push({
+						path: relativePath,
+						message: error instanceof Error ? error.message : String(error),
+					});
+					return Effect4.void;
+				}),
+			);
+			yield* processFile;
+		}
+		for (const [_from, targets] of Object.entries(mutableForward)) {
+			for (const target of targets) {
+				if (!mutableDocuments[target] && !brokenLinks.includes(target)) {
+					brokenLinks.push(target);
+				}
+			}
+		}
+		yield* saveDocumentIndex(storage, {
+			version: docIndex.version,
+			rootPath: storage.rootPath,
+			documents: mutableDocuments,
+		});
+		yield* saveSectionIndex(storage, {
+			version: sectionIndex.version,
+			sections: mutableSections,
+			byHeading: mutableByHeading,
+			byDocument: mutableByDocument,
+		});
+		yield* saveLinkIndex(storage, {
+			version: linkIndex.version,
+			forward: mutableForward,
+			backward: mutableBackward,
+			broken: brokenLinks,
+		});
+		const duration = Date.now() - startTime;
+		const totalLinks = Object.values(mutableForward).reduce(
+			(sum, links) => sum + links.length,
+			0,
+		);
+		return {
+			documentsIndexed,
+			sectionsIndexed,
+			linksIndexed,
+			totalDocuments: Object.keys(mutableDocuments).length,
+			totalSections: Object.keys(mutableSections).length,
+			totalLinks,
+			duration,
+			errors,
+		};
+	});
+var getOutgoingLinks = (rootPath, filePath) =>
+	Effect4.gen(function* () {
+		const storage = createStorage(rootPath);
+		const linkIndex = yield* loadLinkIndex(storage);
+		if (!linkIndex) {
+			return [];
+		}
+		const relativePath = path2.relative(
+			storage.rootPath,
+			path2.resolve(filePath),
+		);
+		return linkIndex.forward[relativePath] ?? [];
+	});
+var getIncomingLinks = (rootPath, filePath) =>
+	Effect4.gen(function* () {
+		const storage = createStorage(rootPath);
+		const linkIndex = yield* loadLinkIndex(storage);
+		if (!linkIndex) {
+			return [];
+		}
+		const relativePath = path2.relative(
+			storage.rootPath,
+			path2.resolve(filePath),
+		);
+		return linkIndex.backward[relativePath] ?? [];
+	});
+var getBrokenLinks = (rootPath) =>
+	Effect4.gen(function* () {
+		const storage = createStorage(rootPath);
+		const linkIndex = yield* loadLinkIndex(storage);
+		if (!linkIndex) {
+			return [];
+		}
+		return linkIndex.broken;
+	});
 
 export {
-  countTokens,
-  countTokensApprox,
-  countWords,
-  freeEncoder,
-  parse,
-  parseFile,
-  INDEX_DIR,
-  INDEX_VERSION,
-  getIndexPaths,
-  computeHash,
-  createStorage,
-  initializeIndex,
-  loadConfig,
-  saveConfig,
-  loadDocumentIndex,
-  saveDocumentIndex,
-  createEmptyDocumentIndex,
-  loadSectionIndex,
-  saveSectionIndex,
-  createEmptySectionIndex,
-  loadLinkIndex,
-  saveLinkIndex,
-  createEmptyLinkIndex,
-  indexExists,
-  buildIndex,
-  getOutgoingLinks,
-  getIncomingLinks,
-  getBrokenLinks
+	countTokens,
+	countTokensApprox,
+	countWords,
+	freeEncoder,
+	parse,
+	parseFile,
+	INDEX_DIR,
+	INDEX_VERSION,
+	getIndexPaths,
+	computeHash,
+	createStorage,
+	initializeIndex,
+	loadConfig,
+	saveConfig,
+	loadDocumentIndex,
+	saveDocumentIndex,
+	createEmptyDocumentIndex,
+	loadSectionIndex,
+	saveSectionIndex,
+	createEmptySectionIndex,
+	loadLinkIndex,
+	saveLinkIndex,
+	createEmptyLinkIndex,
+	indexExists,
+	buildIndex,
+	getOutgoingLinks,
+	getIncomingLinks,
+	getBrokenLinks,
 };