mdcontext 0.0.1 → 0.2.0

package/dist/chunk-S7E6TFX6.js

@@ -0,0 +1,803 @@
+// 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;
+	});
+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);
+};
+var countWords = (text) => {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return 0;
+	return trimmed.split(/\s+/).length;
+};
+var freeEncoder = () => {
+	if (encoder !== null) {
+		encoder.free();
+		encoder = null;
+	}
+};
+
+// src/parser/parser.ts
+import * as crypto from "crypto";
+import { Effect as Effect2 } from "effect";
+import matter from "gray-matter";
+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);
+};
+var slugify = (text) => {
+	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("://");
+};
+var extractPlainText = (node) => {
+	const texts = [];
+	visit(node, "text", (textNode) => {
+		texts.push(textNode.value);
+	});
+	return texts.join(" ");
+};
+var getNodeEndLine = (node) => {
+	return node?.position?.end?.line ?? 0;
+};
+var getNodeStartLine = (node) => {
+	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;
+};
+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;
+};
+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(" ");
+};
+var countAllSections = (sections) => {
+	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;
+};
+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;
+};
+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`,
+});
+
+// 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";
+
+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);
+};
+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);
+		}
+	});
+var loadConfig = (storage) => readJsonFile(storage.paths.config);
+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 createEmptyDocumentIndex = (rootPath) => ({
+	version: INDEX_VERSION,
+	rootPath,
+	documents: {},
+});
+var loadSectionIndex = (storage) => readJsonFile(storage.paths.sections);
+var saveSectionIndex = (storage, index) =>
+	writeJsonFile(storage.paths.sections, index);
+var createEmptySectionIndex = () => ({
+	version: INDEX_VERSION,
+	sections: {},
+	byHeading: {},
+	byDocument: {},
+});
+var loadLinkIndex = (storage) => readJsonFile(storage.paths.links);
+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}`),
+	});
+
+import { Effect as Effect4 } from "effect";
+// src/index/indexer.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+
+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;
+};
+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;
+};
+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;
+};
+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);
+};
+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,
+};