mdcontext 0.0.1 → 0.1.0

package/dist/chunk-S7E6TFX6.js

@@ -0,0 +1,742 @@
+// 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 * 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 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}`)
+});
+
+// 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 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
+};