mdcontext 0.0.1 → 0.1.0

package/dist/chunk-VVTGZNBT.js

@@ -0,0 +1,1519 @@
+import {
+  INDEX_DIR,
+  countTokensApprox,
+  createStorage,
+  loadDocumentIndex,
+  loadSectionIndex,
+  parseFile
+} from "./chunk-S7E6TFX6.js";
+
+// src/summarize/formatters.ts
+var formatSummary = (summary, options = {}) => {
+  const maxTokens = options.maxTokens;
+  const flatSections = [];
+  const collectSections = (section, depth = 0, parentNumber = "", index = 0) => {
+    const number = parentNumber ? `${parentNumber}.${index + 1}` : `${index + 1}`;
+    flatSections.push({ section, depth, number });
+    section.children.forEach((child, i) => {
+      collectSections(child, depth + 1, number, i);
+    });
+  };
+  summary.sections.forEach((section, i) => {
+    collectSections(section, 0, "", i);
+  });
+  const buildOutput = (includedSectionIndices, truncationInfo, includeTopics2) => {
+    const lines = [];
+    if (truncationInfo.showWarning && truncationInfo.truncatedCount > 0 && truncationInfo.tokensTotal > 0) {
+      const pct = Math.round(
+        truncationInfo.tokensShown / truncationInfo.tokensTotal * 100
+      );
+      lines.push(
+        `\u26A0\uFE0F Truncated: Showing ~${truncationInfo.tokensShown}/${truncationInfo.tokensTotal} tokens (${pct}%)`
+      );
+      if (truncationInfo.includedNumbers.length > 0) {
+        const includedDisplay = truncationInfo.includedNumbers.length <= 6 ? truncationInfo.includedNumbers.join(", ") : truncationInfo.includedNumbers.slice(0, 5).join(", ") + `, ... (+${truncationInfo.includedNumbers.length - 5} more)`;
+        lines.push(`Sections included: ${includedDisplay}`);
+      }
+      if (truncationInfo.excludedNumbers.length > 0) {
+        const excludedDisplay = truncationInfo.excludedNumbers.length <= 6 ? truncationInfo.excludedNumbers.join(", ") : truncationInfo.excludedNumbers.slice(0, 5).join(", ") + `, ... (+${truncationInfo.excludedNumbers.length - 5} more)`;
+        lines.push(`Sections excluded: ${excludedDisplay}`);
+      }
+      lines.push(
+        "Use --full for complete content or --section to target specific sections."
+      );
+      lines.push("");
+    }
+    lines.push(`# ${summary.title}`);
+    lines.push(`Path: ${summary.path}`);
+    const tokenLineIndex = lines.length;
+    lines.push("PLACEHOLDER");
+    lines.push("");
+    const fullTopicsLine2 = summary.keyTopics.length > 0 ? `**Topics:** ${summary.keyTopics.join(", ")}` : "";
+    if (includeTopics2 && fullTopicsLine2) {
+      lines.push(fullTopicsLine2);
+      lines.push("");
+    }
+    const sectionLines = [];
+    for (let i = 0; i < flatSections.length; i++) {
+      if (!includedSectionIndices.has(i)) continue;
+      const { section, depth } = flatSections[i];
+      const indent = "  ".repeat(depth);
+      const prefix = "#".repeat(section.level);
+      sectionLines.push(`${indent}${prefix} ${section.heading}`);
+      if (section.summary) {
+        sectionLines.push(`${indent}${section.summary}`);
+      }
+    }
+    lines.push(sectionLines.join("\n"));
+    const tempOutput = lines.join("\n");
+    const tokensWithoutLine = countTokensApprox(
+      tempOutput.replace("PLACEHOLDER", "")
+    );
+    let estimatedTotal = tokensWithoutLine + 8;
+    for (let iter = 0; iter < 3; iter++) {
+      const testTokenLine = `Tokens: ${estimatedTotal} (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`;
+      const testOutput = tempOutput.replace("PLACEHOLDER", testTokenLine);
+      const actualTotal = countTokensApprox(testOutput);
+      if (actualTotal === estimatedTotal) break;
+      estimatedTotal = actualTotal;
+    }
+    const finalTokenLine = `Tokens: ${estimatedTotal} (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`;
+    lines[tokenLineIndex] = finalTokenLine;
+    return lines.join("\n");
+  };
+  if (maxTokens === void 0) {
+    const allIndices = new Set(flatSections.map((_, i) => i));
+    const hasPriorTruncation = summary.truncated && summary.truncatedCount;
+    return buildOutput(
+      allIndices,
+      {
+        showWarning: !!hasPriorTruncation,
+        truncatedCount: summary.truncatedCount ?? 0,
+        includedNumbers: flatSections.map((s) => s.number),
+        excludedNumbers: [],
+        tokensShown: summary.summaryTokens,
+        tokensTotal: summary.originalTokens
+      },
+      true
+    );
+  }
+  const includedIndices = /* @__PURE__ */ new Set();
+  let truncatedCount = 0;
+  let includeTopics = true;
+  const SAFETY_MARGIN = 1.15;
+  const minHeaderTemplate = [
+    `# ${summary.title}`,
+    `Path: ${summary.path}`,
+    `Tokens: 9999 (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`,
+    "",
+    ""
+  ].join("\n");
+  const minHeaderTokens = Math.ceil(
+    countTokensApprox(minHeaderTemplate) * SAFETY_MARGIN
+  );
+  const fullTopicsLine = summary.keyTopics.length > 0 ? `**Topics:** ${summary.keyTopics.join(", ")}
+` : "";
+  const topicsTokens = fullTopicsLine ? Math.ceil(countTokensApprox(fullTopicsLine) * SAFETY_MARGIN) : 0;
+  const truncationWarningTokens = Math.ceil(
+    countTokensApprox(
+      `\u26A0\uFE0F Truncated: Showing ~9999/9999 tokens (99%)
+Sections included: 1, 2, 3, 4, 5, ... (+99 more)
+Sections excluded: 6, 7, 8, 9, 10, ... (+99 more)
+Use --full for complete content or --section to target specific sections.
+`
+    ) * SAFETY_MARGIN
+  );
+  let headerTokens = minHeaderTokens + topicsTokens;
+  if (headerTokens >= maxTokens) {
+    includeTopics = false;
+    headerTokens = minHeaderTokens;
+  }
+  let contentBudget = maxTokens - headerTokens - truncationWarningTokens;
+  let tokensUsed = 0;
+  for (let i = 0; i < flatSections.length; i++) {
+    const { section, depth } = flatSections[i];
+    const indent = "  ".repeat(depth);
+    const prefix = "#".repeat(section.level);
+    const sectionContent = section.summary ? `${indent}${prefix} ${section.heading}
+${indent}${section.summary}` : `${indent}${prefix} ${section.heading}`;
+    const sectionTokens = Math.ceil(
+      countTokensApprox(sectionContent) * SAFETY_MARGIN
+    );
+    if (tokensUsed + sectionTokens <= contentBudget) {
+      includedIndices.add(i);
+      tokensUsed += sectionTokens;
+    } else {
+      truncatedCount++;
+    }
+  }
+  if (truncatedCount === 0) {
+    contentBudget += truncationWarningTokens;
+  }
+  const includedNumbers = [];
+  const excludedNumbers = [];
+  for (let i = 0; i < flatSections.length; i++) {
+    if (includedIndices.has(i)) {
+      includedNumbers.push(flatSections[i].number);
+    } else {
+      excludedNumbers.push(flatSections[i].number);
+    }
+  }
+  let tokensShown = 0;
+  for (const idx of includedIndices) {
+    tokensShown += flatSections[idx].section.summaryTokens;
+  }
+  let output = buildOutput(
+    includedIndices,
+    {
+      showWarning: truncatedCount > 0,
+      truncatedCount,
+      includedNumbers,
+      excludedNumbers,
+      tokensShown,
+      tokensTotal: summary.originalTokens
+    },
+    includeTopics
+  );
+  let actualTokens = countTokensApprox(output);
+  const sortedIndices = Array.from(includedIndices).sort((a, b) => b - a);
+  let removalIndex = 0;
+  while (actualTokens > maxTokens && removalIndex < sortedIndices.length) {
+    const indexToRemove = sortedIndices[removalIndex];
+    includedIndices.delete(indexToRemove);
+    truncatedCount++;
+    removalIndex++;
+    const removedNumber = flatSections[indexToRemove].number;
+    const includedIdx = includedNumbers.indexOf(removedNumber);
+    if (includedIdx !== -1) {
+      includedNumbers.splice(includedIdx, 1);
+      excludedNumbers.push(removedNumber);
+    }
+    tokensShown -= flatSections[indexToRemove].section.summaryTokens;
+    output = buildOutput(
+      includedIndices,
+      {
+        showWarning: true,
+        truncatedCount,
+        includedNumbers,
+        excludedNumbers,
+        tokensShown,
+        tokensTotal: summary.originalTokens
+      },
+      includeTopics
+    );
+    actualTokens = countTokensApprox(output);
+  }
+  if (actualTokens > maxTokens && includeTopics) {
+    includeTopics = false;
+    output = buildOutput(
+      includedIndices,
+      {
+        showWarning: truncatedCount > 0,
+        truncatedCount,
+        includedNumbers,
+        excludedNumbers,
+        tokensShown,
+        tokensTotal: summary.originalTokens
+      },
+      includeTopics
+    );
+    actualTokens = countTokensApprox(output);
+  }
+  if (actualTokens > maxTokens && truncatedCount > 0) {
+    output = buildOutput(
+      includedIndices,
+      {
+        showWarning: false,
+        truncatedCount,
+        includedNumbers,
+        excludedNumbers,
+        tokensShown,
+        tokensTotal: summary.originalTokens
+      },
+      includeTopics
+    );
+    actualTokens = countTokensApprox(output);
+  }
+  return output;
+};
+var formatAssembledContext = (context) => {
+  const lines = [];
+  lines.push("# Context Assembly");
+  lines.push(`Total tokens: ${context.totalTokens}/${context.budget}`);
+  lines.push(`Sources: ${context.sources.length}`);
+  lines.push("");
+  for (const source of context.sources) {
+    lines.push("---");
+    lines.push("");
+    lines.push(source.content);
+  }
+  if (context.overflow.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Overflow (not included due to budget)");
+    for (const overflowPath of context.overflow) {
+      lines.push(`- ${overflowPath}`);
+    }
+  }
+  return lines.join("\n");
+};
+
+// src/summarize/summarizer.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { Effect } from "effect";
+var TOKEN_BUDGETS = {
+  brief: 100,
+  summary: 500,
+  full: Infinity
+};
+var MIN_SENTENCE_LENGTH = 10;
+var SENTENCE_SCORE_DEFINITION = 2;
+var SENTENCE_SCORE_PROPER_START = 1;
+var SENTENCE_SCORE_MEDIUM_LENGTH = 1;
+var SENTENCE_SCORE_EMPHASIS = 1;
+var SENTENCE_LENGTH_MIN = 50;
+var SENTENCE_LENGTH_MAX = 200;
+var SUMMARY_COMPRESSION_RATIO = 0.3;
+var MIN_SECTION_TOKENS = 20;
+var MIN_SUMMARY_SENTENCES = 2;
+var TOKENS_PER_SENTENCE_ESTIMATE = 30;
+var MIN_TOPIC_LENGTH = 2;
+var MAX_TOPIC_LENGTH = 50;
+var MAX_TOPICS = 10;
+var MIN_PARTIAL_BUDGET = 50;
+var extractKeyPoints = (content, maxSentences) => {
+  const sentences = content.replace(/\n+/g, " ").split(/(?<=[.!?])\s+/).filter((s) => s.trim().length > MIN_SENTENCE_LENGTH);
+  if (sentences.length <= maxSentences) {
+    return sentences;
+  }
+  const scored = sentences.map((s) => {
+    let score = 0;
+    if (s.includes(":")) score += SENTENCE_SCORE_DEFINITION;
+    if (/^[A-Z]/.test(s)) score += SENTENCE_SCORE_PROPER_START;
+    if (s.length > SENTENCE_LENGTH_MIN && s.length < SENTENCE_LENGTH_MAX)
+      score += SENTENCE_SCORE_MEDIUM_LENGTH;
+    if (/\*\*|`/.test(s)) score += SENTENCE_SCORE_EMPHASIS;
+    return { sentence: s, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, maxSentences).map((s) => s.sentence);
+};
+var summarizeSection = (section, level) => {
+  const originalTokens = section.metadata.tokenCount;
+  const children = section.children.map(
+    (child) => summarizeSection(child, level)
+  );
+  const targetTokens = Math.min(
+    TOKEN_BUDGETS[level],
+    Math.max(originalTokens * SUMMARY_COMPRESSION_RATIO, MIN_SECTION_TOKENS)
+  );
+  let summary;
+  if (level === "full" || originalTokens <= targetTokens) {
+    summary = section.plainText;
+  } else if (level === "brief") {
+    const meta = [];
+    if (section.metadata.hasCode) meta.push("code");
+    if (section.metadata.hasList) meta.push("list");
+    if (section.metadata.hasTable) meta.push("table");
+    summary = meta.length > 0 ? `[${meta.join(", ")}]` : "";
+  } else {
+    const maxSentences = Math.max(
+      MIN_SUMMARY_SENTENCES,
+      Math.floor(targetTokens / TOKENS_PER_SENTENCE_ESTIMATE)
+    );
+    const keyPoints = extractKeyPoints(section.plainText, maxSentences);
+    if (keyPoints.length > 0) {
+      summary = keyPoints.join(" ");
+    } else {
+      const words = section.plainText.split(/\s+/).slice(0, targetTokens);
+      summary = words.join(" ") + (words.length < section.plainText.split(/\s+/).length ? "..." : "");
+    }
+  }
+  const summaryTokens = countTokensApprox(summary);
+  return {
+    heading: section.heading,
+    level: section.level,
+    originalTokens,
+    summaryTokens,
+    summary,
+    children,
+    hasCode: section.metadata.hasCode,
+    hasList: section.metadata.hasList,
+    hasTable: section.metadata.hasTable
+  };
+};
+var extractTopics = (document) => {
+  const topics = /* @__PURE__ */ new Set();
+  const processSection = (section) => {
+    const cleanHeading = section.heading.replace(/[:#\-_]/g, " ").trim().toLowerCase();
+    if (cleanHeading.length > MIN_TOPIC_LENGTH && cleanHeading.length < MAX_TOPIC_LENGTH) {
+      topics.add(cleanHeading);
+    }
+    for (const child of section.children) {
+      processSection(child);
+    }
+  };
+  for (const section of document.sections) {
+    processSection(section);
+  }
+  const frontmatter = document.frontmatter;
+  if (frontmatter.tags && Array.isArray(frontmatter.tags)) {
+    for (const tag of frontmatter.tags) {
+      if (typeof tag === "string") {
+        topics.add(tag.toLowerCase());
+      }
+    }
+  }
+  return Array.from(topics).slice(0, MAX_TOPICS);
+};
+var summarizeDocument = (document, options = {}) => {
+  const level = options.level ?? "summary";
+  const maxTokens = options.maxTokens ?? TOKEN_BUDGETS[level];
+  const allSections = document.sections.map((s) => summarizeSection(s, level));
+  const originalTokens = document.metadata.tokenCount;
+  let totalSummaryTokens = 0;
+  const flatSections = [];
+  const flattenWithTokens = (section) => {
+    flatSections.push(section);
+    totalSummaryTokens += section.summaryTokens;
+    for (const child of section.children) {
+      flattenWithTokens(child);
+    }
+  };
+  for (const section of allSections) {
+    flattenWithTokens(section);
+  }
+  const topics = extractTopics(document);
+  const headerTemplate = `# ${document.title}
+Path: ${document.path}
+Tokens: 9999 (99% reduction from ${document.metadata.tokenCount})
+`;
+  const topicsLine = topics.length > 0 ? `
+**Topics:** ${topics.join(", ")}
+` : "";
+  const truncationWarning = "\n\u26A0\uFE0F TRUNCATED: 999 sections omitted to fit token budget";
+  const baseOverhead = countTokensApprox(
+    headerTemplate + topicsLine + truncationWarning
+  );
+  const formattingOverhead = Math.ceil(baseOverhead * 1.2) + 20;
+  const contentBudget = maxTokens - formattingOverhead;
+  let truncated = false;
+  let truncatedCount = 0;
+  let sections;
+  let summaryTokens;
+  if (totalSummaryTokens > contentBudget && contentBudget > 0) {
+    let tokensUsed = 0;
+    const truncateSections = (sectionList) => {
+      const result2 = [];
+      for (const section of sectionList) {
+        const sectionOwnTokens = section.summaryTokens;
+        const fitsInBudget = tokensUsed + sectionOwnTokens <= contentBudget;
+        if (fitsInBudget) {
+          tokensUsed += sectionOwnTokens;
+          const truncatedChildren = truncateSections(section.children);
+          result2.push({
+            ...section,
+            children: truncatedChildren
+          });
+        } else {
+          truncatedCount++;
+          const rescuedChildren = truncateSections(section.children);
+          result2.push(...rescuedChildren);
+        }
+      }
+      return result2;
+    };
+    sections = truncateSections(allSections);
+    summaryTokens = tokensUsed;
+    truncated = truncatedCount > 0;
+  } else {
+    sections = allSections;
+    summaryTokens = totalSummaryTokens;
+  }
+  const compressionRatio = originalTokens > 0 ? 1 - summaryTokens / originalTokens : 0;
+  const result = {
+    path: document.path,
+    title: document.title,
+    originalTokens,
+    summaryTokens,
+    compressionRatio,
+    sections,
+    keyTopics: topics
+  };
+  if (truncated) {
+    return {
+      ...result,
+      truncated: true,
+      truncatedCount
+    };
+  }
+  return result;
+};
+var summarizeFile = (filePath, options = {}) => Effect.gen(function* () {
+  const document = yield* parseFile(filePath).pipe(
+    Effect.mapError((e) => new Error(`${e._tag}: ${e.message}`))
+  );
+  return summarizeDocument(document, options);
+});
+var assembleContext = (rootPath, sourcePaths, options) => Effect.gen(function* () {
+  const budget = options.budget;
+  const level = options.level ?? "summary";
+  const sources = [];
+  const overflow = [];
+  let totalTokens = 0;
+  const perSourceBudget = Math.floor(budget / sourcePaths.length);
+  for (const sourcePath of sourcePaths) {
+    const resolvedPath = path.isAbsolute(sourcePath) ? sourcePath : path.join(rootPath, sourcePath);
+    try {
+      const summary = yield* summarizeFile(resolvedPath, {
+        level,
+        maxTokens: perSourceBudget
+      });
+      const content = formatSummary(summary);
+      const tokens = countTokensApprox(content);
+      if (totalTokens + tokens <= budget) {
+        sources.push({
+          path: path.relative(rootPath, resolvedPath),
+          title: summary.title,
+          tokens,
+          content
+        });
+        totalTokens += tokens;
+      } else {
+        const remaining = budget - totalTokens;
+        if (remaining > MIN_PARTIAL_BUDGET) {
+          const briefSummary = yield* summarizeFile(resolvedPath, {
+            level: "brief",
+            maxTokens: remaining
+          });
+          const briefContent = formatSummary(briefSummary);
+          const briefTokens = countTokensApprox(briefContent);
+          sources.push({
+            path: path.relative(rootPath, resolvedPath),
+            title: briefSummary.title,
+            tokens: briefTokens,
+            content: briefContent
+          });
+          totalTokens += briefTokens;
+        } else {
+          overflow.push(path.relative(rootPath, resolvedPath));
+        }
+      }
+    } catch (_e) {
+      overflow.push(sourcePath);
+    }
+  }
+  return {
+    sources,
+    totalTokens,
+    budget,
+    overflow
+  };
+});
+
+// src/embeddings/semantic-search.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import { Effect as Effect4 } from "effect";
+
+// src/embeddings/openai-provider.ts
+import { Console, Effect as Effect2 } from "effect";
+import OpenAI from "openai";
+var PRICING = {
+  "text-embedding-3-small": 0.02,
+  "text-embedding-3-large": 0.13,
+  "text-embedding-ada-002": 0.1
+};
+var MissingApiKeyError = class extends Error {
+  constructor() {
+    super("OPENAI_API_KEY not set");
+    this.name = "MissingApiKeyError";
+  }
+};
+var InvalidApiKeyError = class extends Error {
+  constructor(message) {
+    super(message ?? "Invalid OPENAI_API_KEY");
+    this.name = "InvalidApiKeyError";
+  }
+};
+var OpenAIProvider = class {
+  name;
+  dimensions;
+  client;
+  model;
+  batchSize;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new MissingApiKeyError();
+    }
+    this.client = new OpenAI({ apiKey });
+    this.model = options.model ?? "text-embedding-3-small";
+    this.batchSize = options.batchSize ?? 100;
+    this.name = `openai:${this.model}`;
+    this.dimensions = 512;
+  }
+  async embed(texts) {
+    if (texts.length === 0) {
+      return { embeddings: [], tokensUsed: 0, cost: 0 };
+    }
+    const allEmbeddings = [];
+    let totalTokens = 0;
+    try {
+      for (let i = 0; i < texts.length; i += this.batchSize) {
+        const batch = texts.slice(i, i + this.batchSize);
+        const response = await this.client.embeddings.create({
+          model: this.model,
+          input: batch,
+          dimensions: 512
+          // Ensure consistent dimensions
+        });
+        for (const item of response.data) {
+          allEmbeddings.push(item.embedding);
+        }
+        totalTokens += response.usage?.total_tokens ?? 0;
+      }
+    } catch (error) {
+      if (error instanceof OpenAI.AuthenticationError) {
+        throw new InvalidApiKeyError(error.message);
+      }
+      throw error;
+    }
+    const pricePerMillion = PRICING[this.model] ?? 0.02;
+    const cost = totalTokens / 1e6 * pricePerMillion;
+    return {
+      embeddings: allEmbeddings,
+      tokensUsed: totalTokens,
+      cost
+    };
+  }
+};
+var createOpenAIProvider = (options) => new OpenAIProvider(options);
+var handleApiKeyError = (effect) => effect.pipe(
+  Effect2.catchIf(
+    (e) => e instanceof MissingApiKeyError,
+    () => Effect2.gen(function* () {
+      yield* Console.error("");
+      yield* Console.error("Error: OPENAI_API_KEY not set");
+      yield* Console.error("");
+      yield* Console.error(
+        "To use semantic search, set your OpenAI API key:"
+      );
+      yield* Console.error("  export OPENAI_API_KEY=sk-...");
+      yield* Console.error("");
+      yield* Console.error("Or add to .env file in project root.");
+      return yield* Effect2.fail(new Error("Missing API key"));
+    })
+  ),
+  Effect2.catchIf(
+    (e) => e instanceof InvalidApiKeyError,
+    (e) => Effect2.gen(function* () {
+      yield* Console.error("");
+      yield* Console.error("Error: Invalid OPENAI_API_KEY");
+      yield* Console.error("");
+      yield* Console.error("The provided API key was rejected by OpenAI.");
+      yield* Console.error("Please check your API key is correct:");
+      yield* Console.error("  export OPENAI_API_KEY=sk-...");
+      yield* Console.error("");
+      yield* Console.error(`Details: ${e.message}`);
+      return yield* Effect2.fail(new Error("Invalid API key"));
+    })
+  )
+);
+
+// src/embeddings/vector-store.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { Effect as Effect3 } from "effect";
+import HierarchicalNSW from "hnswlib-node";
+var VECTOR_INDEX_FILE = "vectors.bin";
+var VECTOR_META_FILE = "vectors.meta.json";
+var INDEX_VERSION = 1;
+var HnswVectorStore = class {
+  rootPath;
+  dimensions;
+  index = null;
+  entries = /* @__PURE__ */ new Map();
+  idToIndex = /* @__PURE__ */ new Map();
+  nextIndex = 0;
+  provider = "unknown";
+  totalCost = 0;
+  totalTokens = 0;
+  constructor(rootPath, dimensions) {
+    this.rootPath = path2.resolve(rootPath);
+    this.dimensions = dimensions;
+  }
+  getIndexDir() {
+    return path2.join(this.rootPath, INDEX_DIR);
+  }
+  getVectorPath() {
+    return path2.join(this.getIndexDir(), VECTOR_INDEX_FILE);
+  }
+  getMetaPath() {
+    return path2.join(this.getIndexDir(), VECTOR_META_FILE);
+  }
+  ensureIndex() {
+    if (!this.index) {
+      this.index = new HierarchicalNSW.HierarchicalNSW(
+        "cosine",
+        this.dimensions
+      );
+      this.index.initIndex(1e4, 16, 200, 100);
+    }
+    return this.index;
+  }
+  add(entries) {
+    return Effect3.sync(() => {
+      const index = this.ensureIndex();
+      for (const entry of entries) {
+        if (this.idToIndex.has(entry.id)) {
+          continue;
+        }
+        const idx = this.nextIndex++;
+        if (idx >= index.getMaxElements()) {
+          index.resizeIndex(index.getMaxElements() * 2);
+        }
+        index.addPoint(entry.embedding, idx);
+        this.entries.set(idx, entry);
+        this.idToIndex.set(entry.id, idx);
+      }
+    });
+  }
+  search(vector, limit, threshold = 0) {
+    return Effect3.sync(() => {
+      if (!this.index || this.entries.size === 0) {
+        return [];
+      }
+      const result = this.index.searchKnn(
+        vector,
+        Math.min(limit, this.entries.size)
+      );
+      const results = [];
+      for (let i = 0; i < result.neighbors.length; i++) {
+        const idx = result.neighbors[i];
+        const distance = result.distances[i];
+        if (idx === void 0 || distance === void 0) {
+          continue;
+        }
+        const similarity = 1 - distance;
+        if (similarity < threshold) {
+          continue;
+        }
+        const entry = this.entries.get(idx);
+        if (entry) {
+          results.push({
+            id: entry.id,
+            sectionId: entry.sectionId,
+            documentPath: entry.documentPath,
+            heading: entry.heading,
+            similarity
+          });
+        }
+      }
+      return results;
+    });
+  }
+  save() {
+    return Effect3.gen(
+      function* () {
+        if (!this.index) {
+          return;
+        }
+        const indexDir = this.getIndexDir();
+        yield* Effect3.promise(() => fs2.mkdir(indexDir, { recursive: true }));
+        yield* Effect3.promise(
+          () => this.index.writeIndex(this.getVectorPath())
+        );
+        const meta = {
+          version: INDEX_VERSION,
+          provider: this.provider,
+          dimensions: this.dimensions,
+          entries: Object.fromEntries(
+            Array.from(this.entries.entries()).map(([idx, entry]) => [
+              idx.toString(),
+              entry
+            ])
+          ),
+          totalCost: this.totalCost,
+          totalTokens: this.totalTokens,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        yield* Effect3.promise(
+          () => fs2.writeFile(this.getMetaPath(), JSON.stringify(meta, null, 2))
+        );
+      }.bind(this)
+    );
+  }
+  load() {
+    return Effect3.gen(
+      function* () {
+        const vectorPath = this.getVectorPath();
+        const metaPath = this.getMetaPath();
+        const filesExist = yield* Effect3.tryPromise({
+          try: async () => {
+            await fs2.access(vectorPath);
+            await fs2.access(metaPath);
+            return true;
+          },
+          catch: () => false
+        }).pipe(Effect3.catchAll(() => Effect3.succeed(false)));
+        if (!filesExist) {
+          return false;
+        }
+        const metaContent = yield* Effect3.promise(
+          () => fs2.readFile(metaPath, "utf-8")
+        );
+        const meta = JSON.parse(metaContent);
+        if (meta.dimensions !== this.dimensions) {
+          return false;
+        }
+        this.index = new HierarchicalNSW.HierarchicalNSW(
+          "cosine",
+          this.dimensions
+        );
+        yield* Effect3.promise(() => this.index.readIndex(vectorPath));
+        this.entries.clear();
+        this.idToIndex.clear();
+        this.nextIndex = 0;
+        for (const [idxStr, entry] of Object.entries(meta.entries)) {
+          const idx = parseInt(idxStr, 10);
+          this.entries.set(idx, entry);
+          this.idToIndex.set(entry.id, idx);
+          this.nextIndex = Math.max(this.nextIndex, idx + 1);
+        }
+        this.provider = meta.provider;
+        this.totalCost = meta.totalCost;
+        this.totalTokens = meta.totalTokens;
+        return true;
+      }.bind(this)
+    );
+  }
+  getStats() {
+    return {
+      count: this.entries.size,
+      dimensions: this.dimensions,
+      provider: this.provider,
+      totalCost: this.totalCost,
+      totalTokens: this.totalTokens
+    };
+  }
+  setProvider(name) {
+    this.provider = name;
+  }
+  addCost(cost, tokens) {
+    this.totalCost += cost;
+    this.totalTokens += tokens;
+  }
+};
+var createVectorStore = (rootPath, dimensions) => new HnswVectorStore(rootPath, dimensions);
+
+// src/embeddings/semantic-search.ts
+var generateEmbeddingText = (section, content, documentTitle, parentHeading) => {
+  const parts = [];
+  parts.push(`# ${section.heading}`);
+  if (parentHeading) {
+    parts.push(`Parent section: ${parentHeading}`);
+  }
+  parts.push(`Document: ${documentTitle}`);
+  parts.push("");
+  parts.push(content);
+  return parts.join("\n");
+};
+var EMBEDDING_PRICE_PER_MILLION = 0.02;
+var estimateEmbeddingCost = (rootPath, options = {}) => Effect4.gen(function* () {
+  const resolvedRoot = path3.resolve(rootPath);
+  const storage = createStorage(resolvedRoot);
+  const docIndex = yield* loadDocumentIndex(storage);
+  const sectionIndex = yield* loadSectionIndex(storage);
+  if (!docIndex || !sectionIndex) {
+    return yield* Effect4.fail(
+      new Error("Index not found. Run 'mdcontext index' first.")
+    );
+  }
+  const byDir = /* @__PURE__ */ new Map();
+  for (const section of Object.values(sectionIndex.sections)) {
+    if (section.tokenCount < 10) continue;
+    if (options.excludePatterns?.length) {
+      const excluded = options.excludePatterns.some((pattern) => {
+        const regex = new RegExp(
+          `^${pattern.replace(/\*/g, ".*").replace(/\?/g, ".")}$`
+        );
+        return regex.test(section.documentPath);
+      });
+      if (excluded) continue;
+    }
+    const dir = path3.dirname(section.documentPath) || ".";
+    if (!byDir.has(dir)) {
+      byDir.set(dir, { files: /* @__PURE__ */ new Set(), sections: 0, tokens: 0 });
+    }
+    const entry = byDir.get(dir);
+    entry.files.add(section.documentPath);
+    entry.sections++;
+    entry.tokens += section.tokenCount;
+  }
+  const directoryEstimates = [];
+  let totalFiles = 0;
+  let totalSections = 0;
+  let totalTokens = 0;
+  for (const [dir, data] of byDir) {
+    directoryEstimates.push({
+      directory: dir,
+      fileCount: data.files.size,
+      sectionCount: data.sections,
+      estimatedTokens: data.tokens,
+      estimatedCost: data.tokens / 1e6 * EMBEDDING_PRICE_PER_MILLION
+    });
+    totalFiles += data.files.size;
+    totalSections += data.sections;
+    totalTokens += data.tokens;
+  }
+  directoryEstimates.sort((a, b) => a.directory.localeCompare(b.directory));
+  const estimatedTimeSeconds = Math.ceil(totalSections / 100) * 1.5;
+  return {
+    totalFiles,
+    totalSections,
+    totalTokens,
+    totalCost: totalTokens / 1e6 * EMBEDDING_PRICE_PER_MILLION,
+    estimatedTimeSeconds,
+    byDirectory: directoryEstimates
+  };
+});
+var buildEmbeddings = (rootPath, options = {}) => Effect4.gen(function* () {
+  const startTime = Date.now();
+  const resolvedRoot = path3.resolve(rootPath);
+  const storage = createStorage(resolvedRoot);
+  const docIndex = yield* loadDocumentIndex(storage);
+  const sectionIndex = yield* loadSectionIndex(storage);
+  if (!docIndex || !sectionIndex) {
+    return yield* Effect4.fail(
+      new Error("Index not found. Run 'mdcontext index' first.")
+    );
+  }
+  const provider = options.provider ?? (yield* Effect4.try({
+    try: () => createOpenAIProvider(),
+    catch: (e) => e
+  }));
+  const dimensions = provider.dimensions;
+  const vectorStore = createVectorStore(
+    resolvedRoot,
+    dimensions
+  );
+  vectorStore.setProvider(provider.name);
+  if (!options.force) {
+    const loaded = yield* vectorStore.load();
+    if (loaded) {
+      const stats = vectorStore.getStats();
+      if (stats.count > 0) {
+        const duration2 = Date.now() - startTime;
+        const estimatedSavings = stats.totalTokens / 1e6 * EMBEDDING_PRICE_PER_MILLION;
+        return {
+          sectionsEmbedded: 0,
+          tokensUsed: 0,
+          cost: 0,
+          duration: duration2,
+          filesProcessed: 0,
+          cacheHit: true,
+          existingVectors: stats.count,
+          estimatedSavings
+        };
+      }
+    }
+  }
+  const isExcluded = (docPath) => {
+    if (!options.excludePatterns?.length) return false;
+    return options.excludePatterns.some((pattern) => {
+      const regex = new RegExp(
+        `^${pattern.replace(/\*/g, ".*").replace(/\?/g, ".")}$`
+      );
+      return regex.test(docPath);
+    });
+  };
+  const sectionsByDoc = /* @__PURE__ */ new Map();
+  for (const section of Object.values(sectionIndex.sections)) {
+    const document = docIndex.documents[section.documentPath];
+    if (!document) continue;
+    if (section.tokenCount < 10) continue;
+    if (isExcluded(section.documentPath)) continue;
+    let parentHeading;
+    if (section.level > 1) {
+      const docSections = sectionIndex.byDocument[document.id] ?? [];
+      for (const sibId of docSections) {
+        const sib = sectionIndex.sections[sibId];
+        if (sib && sib.level === section.level - 1 && sib.startLine < section.startLine) {
+          parentHeading = sib.heading;
+        }
+      }
+    }
+    const docPath = section.documentPath;
+    if (!sectionsByDoc.has(docPath)) {
+      sectionsByDoc.set(docPath, []);
+    }
+    sectionsByDoc.get(docPath).push({ section, parentHeading });
+  }
+  if (sectionsByDoc.size === 0) {
+    const duration2 = Date.now() - startTime;
+    return {
+      sectionsEmbedded: 0,
+      tokensUsed: 0,
+      cost: 0,
+      duration: duration2,
+      filesProcessed: 0
+    };
+  }
+  const sectionsToEmbed = [];
+  const docPaths = Array.from(sectionsByDoc.keys());
+  let filesProcessed = 0;
+  for (let fileIndex = 0; fileIndex < docPaths.length; fileIndex++) {
+    const docPath = docPaths[fileIndex];
+    const sections = sectionsByDoc.get(docPath);
+    const document = docIndex.documents[docPath];
+    if (!document) continue;
+    if (options.onFileProgress) {
+      options.onFileProgress({
+        fileIndex: fileIndex + 1,
+        totalFiles: docPaths.length,
+        filePath: docPath,
+        sectionCount: sections.length
+      });
+    }
+    const filePath = path3.join(resolvedRoot, docPath);
+    let fileContent;
+    try {
+      fileContent = yield* Effect4.promise(
+        () => fs3.readFile(filePath, "utf-8")
+      );
+    } catch {
+      continue;
+    }
+    filesProcessed++;
+    const lines = fileContent.split("\n");
+    for (const { section, parentHeading } of sections) {
+      const content = lines.slice(section.startLine - 1, section.endLine).join("\n");
+      const text = generateEmbeddingText(
+        section,
+        content,
+        document.title,
+        parentHeading
+      );
+      sectionsToEmbed.push({ section, text });
+    }
+  }
+  if (sectionsToEmbed.length === 0) {
+    const duration2 = Date.now() - startTime;
+    return {
+      sectionsEmbedded: 0,
+      tokensUsed: 0,
+      cost: 0,
+      duration: duration2,
+      filesProcessed
+    };
+  }
+  const texts = sectionsToEmbed.map((s) => s.text);
+  const result = yield* Effect4.tryPromise({
+    try: () => provider.embed(texts),
+    catch: (e) => {
+      if (e instanceof InvalidApiKeyError) return e;
+      return new Error(
+        `Embedding failed: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  });
+  const entries = [];
+  for (let i = 0; i < sectionsToEmbed.length; i++) {
+    const { section } = sectionsToEmbed[i] ?? { section: null };
+    const embedding = result.embeddings[i];
+    if (!section || !embedding) continue;
+    entries.push({
+      id: section.id,
+      sectionId: section.id,
+      documentPath: section.documentPath,
+      heading: section.heading,
+      embedding
+    });
+  }
+  yield* vectorStore.add(entries);
+  vectorStore.addCost(result.cost, result.tokensUsed);
+  yield* vectorStore.save();
+  const duration = Date.now() - startTime;
+  return {
+    sectionsEmbedded: entries.length,
+    tokensUsed: result.tokensUsed,
+    cost: result.cost,
+    duration,
+    filesProcessed
+  };
+});
+var semanticSearch = (rootPath, query, options = {}) => Effect4.gen(function* () {
+  const resolvedRoot = path3.resolve(rootPath);
+  const provider = yield* Effect4.try({
+    try: () => createOpenAIProvider(),
+    catch: (e) => e
+  });
+  const dimensions = provider.dimensions;
+  const vectorStore = createVectorStore(resolvedRoot, dimensions);
+  const loaded = yield* vectorStore.load();
+  if (!loaded) {
+    return yield* Effect4.fail(
+      new Error("Embeddings not found. Run 'mdcontext embed' first.")
+    );
+  }
+  const queryResult = yield* Effect4.tryPromise({
+    try: () => provider.embed([query]),
+    catch: (e) => new Error(
+      `Query embedding failed: ${e instanceof Error ? e.message : String(e)}`
+    )
+  });
+  const queryVector = queryResult.embeddings[0];
+  if (!queryVector) {
+    return yield* Effect4.fail(new Error("Failed to generate query embedding"));
+  }
+  const limit = options.limit ?? 10;
+  const threshold = options.threshold ?? 0;
+  const searchResults = yield* vectorStore.search(
+    queryVector,
+    limit * 2,
+    threshold
+  );
+  let filteredResults = searchResults;
+  if (options.pathPattern) {
+    const pattern = options.pathPattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${pattern}$`, "i");
+    filteredResults = searchResults.filter((r) => regex.test(r.documentPath));
+  }
+  const results = filteredResults.slice(0, limit).map((r) => ({
+    sectionId: r.sectionId,
+    documentPath: r.documentPath,
+    heading: r.heading,
+    similarity: r.similarity
+  }));
+  return results;
+});
+var getEmbeddingStats = (rootPath) => Effect4.gen(function* () {
+  const resolvedRoot = path3.resolve(rootPath);
+  const vectorStore = createVectorStore(resolvedRoot, 1536);
+  const loaded = yield* vectorStore.load();
+  if (!loaded) {
+    return {
+      hasEmbeddings: false,
+      count: 0,
+      provider: "none",
+      dimensions: 0,
+      totalCost: 0,
+      totalTokens: 0
+    };
+  }
+  const stats = vectorStore.getStats();
+  return {
+    hasEmbeddings: true,
+    count: stats.count,
+    provider: stats.provider,
+    dimensions: stats.dimensions,
+    totalCost: stats.totalCost,
+    totalTokens: stats.totalTokens
+  };
+});
+
+// src/search/searcher.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import { Effect as Effect5 } from "effect";
+
+// src/search/query-parser.ts
+var tokenize = (query) => {
+  const tokens = [];
+  let i = 0;
+  while (i < query.length) {
+    if (/\s/.test(query[i])) {
+      i++;
+      continue;
+    }
+    if (query[i] === '"') {
+      const start = i + 1;
+      i++;
+      while (i < query.length && query[i] !== '"') {
+        i++;
+      }
+      const value = query.slice(start, i);
+      tokens.push({ type: "PHRASE", value });
+      i++;
+      continue;
+    }
+    if (query[i] === "(") {
+      tokens.push({ type: "LPAREN", value: "(" });
+      i++;
+      continue;
+    }
+    if (query[i] === ")") {
+      tokens.push({ type: "RPAREN", value: ")" });
+      i++;
+      continue;
+    }
+    const wordMatch = query.slice(i).match(/^[^\s()"]+/);
+    if (wordMatch) {
+      const word = wordMatch[0];
+      const upperWord = word.toUpperCase();
+      if (upperWord === "AND") {
+        tokens.push({ type: "AND", value: "AND" });
+      } else if (upperWord === "OR") {
+        tokens.push({ type: "OR", value: "OR" });
+      } else if (upperWord === "NOT") {
+        tokens.push({ type: "NOT", value: "NOT" });
+      } else {
+        tokens.push({ type: "TERM", value: word });
+      }
+      i += word.length;
+      continue;
+    }
+    i++;
+  }
+  return tokens;
+};
+var Parser = class {
+  tokens;
+  pos = 0;
+  terms = [];
+  phrases = [];
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  current() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    return this.tokens[this.pos++];
+  }
+  match(type) {
+    if (this.current()?.type === type) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  parse() {
+    if (this.tokens.length === 0) {
+      return null;
+    }
+    return this.parseExpr();
+  }
+  parseExpr() {
+    let left = this.parseAndExpr();
+    while (this.match("OR")) {
+      const right = this.parseAndExpr();
+      left = { type: "or", left, right };
+    }
+    return left;
+  }
+  parseAndExpr() {
+    let left = this.parseNotExpr();
+    while (this.match("AND") || this.isImplicitAnd()) {
+      const right = this.parseNotExpr();
+      left = { type: "and", left, right };
+    }
+    return left;
+  }
+  isImplicitAnd() {
+    const tok = this.current();
+    return tok?.type === "TERM" || tok?.type === "PHRASE" || tok?.type === "NOT" || tok?.type === "LPAREN";
+  }
+  parseNotExpr() {
+    if (this.match("NOT")) {
+      const operand = this.parseNotExpr();
+      return { type: "not", operand };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const tok = this.current();
+    if (this.match("LPAREN")) {
+      const expr = this.parseExpr();
+      this.match("RPAREN");
+      return expr;
+    }
+    if (tok?.type === "PHRASE") {
+      this.advance();
+      this.phrases.push(tok.value);
+      return { type: "phrase", value: tok.value };
+    }
+    if (tok?.type === "TERM") {
+      this.advance();
+      this.terms.push(tok.value);
+      return { type: "term", value: tok.value };
+    }
+    return { type: "term", value: "" };
+  }
+};
+var parseQuery = (query) => {
+  const tokens = tokenize(query);
+  if (tokens.length === 0) {
+    return null;
+  }
+  const parser = new Parser(tokens);
+  const ast = parser.parse();
+  if (!ast) {
+    return null;
+  }
+  return {
+    ast,
+    terms: parser.terms,
+    phrases: parser.phrases
+  };
+};
+var isAdvancedQuery = (query) => {
+  const tokens = tokenize(query);
+  return tokens.some(
+    (t) => t.type === "AND" || t.type === "OR" || t.type === "NOT" || t.type === "PHRASE" || t.type === "LPAREN"
+  );
+};
+var evaluateQuery = (ast, text) => {
+  const lowerText = text.toLowerCase();
+  const evaluate = (node) => {
+    switch (node.type) {
+      case "term": {
+        if (!node.value) return true;
+        return lowerText.includes(node.value.toLowerCase());
+      }
+      case "phrase": {
+        return lowerText.includes(node.value.toLowerCase());
+      }
+      case "and": {
+        return evaluate(node.left) && evaluate(node.right);
+      }
+      case "or": {
+        return evaluate(node.left) || evaluate(node.right);
+      }
+      case "not": {
+        return !evaluate(node.operand);
+      }
+    }
+  };
+  return evaluate(ast);
+};
+var buildHighlightPattern = (parsed) => {
+  const patterns = [];
+  const escapeChars = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const term of parsed.terms) {
+    if (term) {
+      patterns.push(`\\b${escapeChars(term)}\\b`);
+    }
+  }
+  for (const phrase of parsed.phrases) {
+    if (phrase) {
+      patterns.push(escapeChars(phrase));
+    }
+  }
+  if (patterns.length === 0) {
+    return /.^/;
+  }
+  return new RegExp(patterns.join("|"), "gi");
+};
+
+// src/search/searcher.ts
+var matchPath = (filePath, pattern) => {
+  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(filePath);
+};
+var search = (rootPath, options = {}) => Effect5.gen(function* () {
+  const storage = createStorage(rootPath);
+  const docIndex = yield* loadDocumentIndex(storage);
+  const sectionIndex = yield* loadSectionIndex(storage);
+  if (!docIndex || !sectionIndex) {
+    return [];
+  }
+  const results = [];
+  const headingRegex = options.heading ? new RegExp(options.heading, "i") : null;
+  for (const section of Object.values(sectionIndex.sections)) {
+    if (headingRegex && !headingRegex.test(section.heading)) {
+      continue;
+    }
+    if (options.pathPattern && !matchPath(section.documentPath, options.pathPattern)) {
+      continue;
+    }
+    if (options.hasCode !== void 0 && section.hasCode !== options.hasCode) {
+      continue;
+    }
+    if (options.hasList !== void 0 && section.hasList !== options.hasList) {
+      continue;
+    }
+    if (options.hasTable !== void 0 && section.hasTable !== options.hasTable) {
+      continue;
+    }
+    if (options.minLevel !== void 0 && section.level < options.minLevel) {
+      continue;
+    }
+    if (options.maxLevel !== void 0 && section.level > options.maxLevel) {
+      continue;
+    }
+    const document = docIndex.documents[section.documentPath];
+    if (document) {
+      results.push({ section, document });
+    }
+    if (options.limit !== void 0 && results.length >= options.limit) {
+      break;
+    }
+  }
+  return results;
+});
+var searchContent = (rootPath, options = {}) => Effect5.gen(function* () {
+  const storage = createStorage(rootPath);
+  const docIndex = yield* loadDocumentIndex(storage);
+  const sectionIndex = yield* loadSectionIndex(storage);
+  if (!docIndex || !sectionIndex) {
+    return [];
+  }
+  let parsedQuery = null;
+  let contentRegex = null;
+  let highlightRegex = null;
+  if (options.content) {
+    if (isAdvancedQuery(options.content)) {
+      parsedQuery = parseQuery(options.content);
+      if (parsedQuery) {
+        highlightRegex = buildHighlightPattern(parsedQuery);
+      }
+    } else {
+      contentRegex = new RegExp(options.content, "gi");
+      highlightRegex = contentRegex;
+    }
+  }
+  const headingRegex = options.heading ? new RegExp(options.heading, "i") : null;
+  const results = [];
+  const sectionsByDoc = {};
+  for (const section of Object.values(sectionIndex.sections)) {
+    const docSections = sectionsByDoc[section.documentPath];
+    if (docSections) {
+      docSections.push(section);
+    } else {
+      sectionsByDoc[section.documentPath] = [section];
+    }
+  }
+  for (const [docPath, sections] of Object.entries(sectionsByDoc)) {
+    if (options.pathPattern && !matchPath(docPath, options.pathPattern)) {
+      continue;
+    }
+    const document = docIndex.documents[docPath];
+    if (!document) continue;
+    let fileContent = null;
+    let fileLines = [];
+    if (parsedQuery || contentRegex) {
+      const filePath = path4.join(storage.rootPath, docPath);
+      try {
+        fileContent = yield* Effect5.promise(
+          () => fs4.readFile(filePath, "utf-8")
+        );
+        fileLines = fileContent.split("\n");
+      } catch {
+        continue;
+      }
+    }
+    for (const section of sections) {
+      if (headingRegex && !headingRegex.test(section.heading)) {
+        continue;
+      }
+      if (options.hasCode !== void 0 && section.hasCode !== options.hasCode) {
+        continue;
+      }
+      if (options.hasList !== void 0 && section.hasList !== options.hasList) {
+        continue;
+      }
+      if (options.hasTable !== void 0 && section.hasTable !== options.hasTable) {
+        continue;
+      }
+      if (options.minLevel !== void 0 && section.level < options.minLevel) {
+        continue;
+      }
+      if (options.maxLevel !== void 0 && section.level > options.maxLevel) {
+        continue;
+      }
+      if ((parsedQuery || contentRegex) && fileContent) {
+        const sectionLines = fileLines.slice(
+          section.startLine - 1,
+          section.endLine
+        );
+        const sectionContent = sectionLines.join("\n");
+        if (parsedQuery) {
+          if (!evaluateQuery(parsedQuery.ast, sectionContent)) {
+            continue;
+          }
+        }
+        const matches = [];
+        const searchRegex = contentRegex || highlightRegex;
+        const contextBefore = options.contextBefore ?? 1;
+        const contextAfter = options.contextAfter ?? 1;
+        if (searchRegex) {
+          for (let i = 0; i < sectionLines.length; i++) {
+            const line = sectionLines[i];
+            if (line && searchRegex.test(line)) {
+              searchRegex.lastIndex = 0;
+              const absoluteLineNum = section.startLine + i;
+              const snippetStart = Math.max(0, i - contextBefore);
+              const snippetEnd = Math.min(
+                sectionLines.length,
+                i + contextAfter + 1
+              );
+              const snippetLines = sectionLines.slice(
+                snippetStart,
+                snippetEnd
+              );
+              const snippet = snippetLines.join("\n");
+              const contextLines = [];
+              for (let j = snippetStart; j < snippetEnd; j++) {
+                const ctxLine = sectionLines[j];
+                if (ctxLine !== void 0) {
+                  contextLines.push({
+                    lineNumber: section.startLine + j,
+                    line: ctxLine,
+                    isMatch: j === i
+                  });
+                }
+              }
+              matches.push({
+                lineNumber: absoluteLineNum,
+                line,
+                snippet,
+                contextLines
+              });
+            }
+          }
+        }
+        if (parsedQuery || matches.length > 0) {
+          const result = {
+            section,
+            document,
+            sectionContent
+          };
+          if (matches.length > 0) {
+            results.push({ ...result, matches });
+          } else {
+            results.push(result);
+          }
+          if (options.limit !== void 0 && results.length >= options.limit) {
+            return results;
+          }
+        }
+      } else if (!parsedQuery && !contentRegex) {
+        results.push({ section, document });
+        if (options.limit !== void 0 && results.length >= options.limit) {
+          return results;
+        }
+      }
+    }
+  }
+  return results;
+});
+
+export {
+  formatSummary,
+  formatAssembledContext,
+  summarizeFile,
+  assembleContext,
+  handleApiKeyError,
+  estimateEmbeddingCost,
+  buildEmbeddings,
+  semanticSearch,
+  getEmbeddingStats,
+  isAdvancedQuery,
+  search,
+  searchContent
+};