mdcontext 0.1.0 → 0.2.0

package/dist/chunk-VVTGZNBT.js

@@ -1,271 +1,305 @@
 import {
-  INDEX_DIR,
-  countTokensApprox,
-  createStorage,
-  loadDocumentIndex,
-  loadSectionIndex,
-  parseFile
+	countTokensApprox,
+	createStorage,
+	INDEX_DIR,
+	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%)
+	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;
+`,
+		) * 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");
+	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");
 };
 
+import { Effect } from "effect";
 // 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
+	brief: 100,
+	summary: 500,
+	full: Infinity,
 };
 var MIN_SENTENCE_LENGTH = 10;
 var SENTENCE_SCORE_DEFINITION = 2;
@@ -283,1237 +317,1313 @@ 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);
+	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
-  };
+	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);
+	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}
+	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 ? `
+	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;
+`
+			: "";
+	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
-  };
-});
+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/openai-provider.ts
+import { Console, Effect as Effect2, Effect as Effect4 } from "effect";
 // src/embeddings/semantic-search.ts
 import * as fs3 from "fs/promises";
+import OpenAI from "openai";
 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
+	"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";
-  }
+	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";
-  }
+	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
-    };
-  }
+	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"));
-    })
-  )
-);
+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"));
+				}),
+		),
+	);
 
+import { Effect as Effect3 } from "effect";
 // 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";
+import * as path2 from "path";
+
 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;
-  }
+	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);
+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 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
-  };
-});
+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,
+		};
+	});
 
+import { Effect as Effect5 } from "effect";
 // 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;
+	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: "" };
-  }
+	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
-  };
+	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"
-  );
+	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);
+	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");
+	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);
+	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;
-});
+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
+	formatSummary,
+	formatAssembledContext,
+	summarizeFile,
+	assembleContext,
+	handleApiKeyError,
+	estimateEmbeddingCost,
+	buildEmbeddings,
+	semanticSearch,
+	getEmbeddingStats,
+	isAdvancedQuery,
+	search,
+	searchContent,
 };