mdcontext 0.0.1 → 0.2.0

package/dist/chunk-OBELGBPM.js

@@ -0,0 +1,1713 @@
+import {
+	ApiKeyInvalidError,
+	ApiKeyMissingError,
+	countTokensApprox,
+	createStorage,
+	EmbeddingError,
+	EmbeddingsNotFoundError,
+	INDEX_DIR,
+	IndexNotFoundError,
+	loadDocumentIndex,
+	loadSectionIndex,
+	parseFile,
+	VectorStoreError,
+} from "./chunk-QNN4TT23.js";
+
+// src/summarize/formatters.ts
+var formatSummary = (summary, options = {}) => {
+	const maxTokens = options.maxTokens;
+	const flatSections = [];
+	const collectSections = (
+		section,
+		depth = 0,
+		parentNumber = "",
+		index = 0,
+	) => {
+		const number = parentNumber
+			? `${parentNumber}.${index + 1}`
+			: `${index + 1}`;
+		flatSections.push({ section, depth, number });
+		section.children.forEach((child, i) => {
+			collectSections(child, depth + 1, number, i);
+		});
+	};
+	summary.sections.forEach((section, i) => {
+		collectSections(section, 0, "", i);
+	});
+	const buildOutput = (
+		includedSectionIndices,
+		truncationInfo,
+		includeTopics2,
+	) => {
+		const lines = [];
+		if (
+			truncationInfo.showWarning &&
+			truncationInfo.truncatedCount > 0 &&
+			truncationInfo.tokensTotal > 0
+		) {
+			const pct = Math.round(
+				(truncationInfo.tokensShown / truncationInfo.tokensTotal) * 100,
+			);
+			lines.push(
+				`\u26A0\uFE0F Truncated: Showing ~${truncationInfo.tokensShown}/${truncationInfo.tokensTotal} tokens (${pct}%)`,
+			);
+			if (truncationInfo.includedNumbers.length > 0) {
+				const includedDisplay =
+					truncationInfo.includedNumbers.length <= 6
+						? truncationInfo.includedNumbers.join(", ")
+						: truncationInfo.includedNumbers.slice(0, 5).join(", ") +
+							`, ... (+${truncationInfo.includedNumbers.length - 5} more)`;
+				lines.push(`Sections included: ${includedDisplay}`);
+			}
+			if (truncationInfo.excludedNumbers.length > 0) {
+				const excludedDisplay =
+					truncationInfo.excludedNumbers.length <= 6
+						? truncationInfo.excludedNumbers.join(", ")
+						: truncationInfo.excludedNumbers.slice(0, 5).join(", ") +
+							`, ... (+${truncationInfo.excludedNumbers.length - 5} more)`;
+				lines.push(`Sections excluded: ${excludedDisplay}`);
+			}
+			lines.push(
+				"Use --full for complete content or --section to target specific sections.",
+			);
+			lines.push("");
+		}
+		lines.push(`# ${summary.title}`);
+		lines.push(`Path: ${summary.path}`);
+		const tokenLineIndex = lines.length;
+		lines.push("PLACEHOLDER");
+		lines.push("");
+		const fullTopicsLine2 =
+			summary.keyTopics.length > 0
+				? `**Topics:** ${summary.keyTopics.join(", ")}`
+				: "";
+		if (includeTopics2 && fullTopicsLine2) {
+			lines.push(fullTopicsLine2);
+			lines.push("");
+		}
+		const sectionLines = [];
+		for (let i = 0; i < flatSections.length; i++) {
+			if (!includedSectionIndices.has(i)) continue;
+			const { section, depth } = flatSections[i];
+			const indent = "  ".repeat(depth);
+			const prefix = "#".repeat(section.level);
+			sectionLines.push(`${indent}${prefix} ${section.heading}`);
+			if (section.summary) {
+				sectionLines.push(`${indent}${section.summary}`);
+			}
+		}
+		lines.push(sectionLines.join("\n"));
+		const tempOutput = lines.join("\n");
+		const tokensWithoutLine = countTokensApprox(
+			tempOutput.replace("PLACEHOLDER", ""),
+		);
+		let estimatedTotal = tokensWithoutLine + 8;
+		for (let iter = 0; iter < 3; iter++) {
+			const testTokenLine = `Tokens: ${estimatedTotal} (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`;
+			const testOutput = tempOutput.replace("PLACEHOLDER", testTokenLine);
+			const actualTotal = countTokensApprox(testOutput);
+			if (actualTotal === estimatedTotal) break;
+			estimatedTotal = actualTotal;
+		}
+		const finalTokenLine = `Tokens: ${estimatedTotal} (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`;
+		lines[tokenLineIndex] = finalTokenLine;
+		return lines.join("\n");
+	};
+	if (maxTokens === void 0) {
+		const allIndices = new Set(flatSections.map((_, i) => i));
+		const hasPriorTruncation = summary.truncated && summary.truncatedCount;
+		return buildOutput(
+			allIndices,
+			{
+				showWarning: !!hasPriorTruncation,
+				truncatedCount: summary.truncatedCount ?? 0,
+				includedNumbers: flatSections.map((s) => s.number),
+				excludedNumbers: [],
+				tokensShown: summary.summaryTokens,
+				tokensTotal: summary.originalTokens,
+			},
+			true,
+		);
+	}
+	const includedIndices = /* @__PURE__ */ new Set();
+	let truncatedCount = 0;
+	let includeTopics = true;
+	const SAFETY_MARGIN = 1.15;
+	const minHeaderTemplate = [
+		`# ${summary.title}`,
+		`Path: ${summary.path}`,
+		`Tokens: 9999 (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`,
+		"",
+		"",
+	].join("\n");
+	const minHeaderTokens = Math.ceil(
+		countTokensApprox(minHeaderTemplate) * SAFETY_MARGIN,
+	);
+	const fullTopicsLine =
+		summary.keyTopics.length > 0
+			? `**Topics:** ${summary.keyTopics.join(", ")}
+`
+			: "";
+	const topicsTokens = fullTopicsLine
+		? Math.ceil(countTokensApprox(fullTopicsLine) * SAFETY_MARGIN)
+		: 0;
+	const truncationWarningTokens = Math.ceil(
+		countTokensApprox(
+			`\u26A0\uFE0F Truncated: Showing ~9999/9999 tokens (99%)
+Sections included: 1, 2, 3, 4, 5, ... (+99 more)
+Sections excluded: 6, 7, 8, 9, 10, ... (+99 more)
+Use --full for complete content or --section to target specific sections.
+`,
+		) * SAFETY_MARGIN,
+	);
+	let headerTokens = minHeaderTokens + topicsTokens;
+	if (headerTokens >= maxTokens) {
+		includeTopics = false;
+		headerTokens = minHeaderTokens;
+	}
+	let contentBudget = maxTokens - headerTokens - truncationWarningTokens;
+	let tokensUsed = 0;
+	for (let i = 0; i < flatSections.length; i++) {
+		const { section, depth } = flatSections[i];
+		const indent = "  ".repeat(depth);
+		const prefix = "#".repeat(section.level);
+		const sectionContent = section.summary
+			? `${indent}${prefix} ${section.heading}
+${indent}${section.summary}`
+			: `${indent}${prefix} ${section.heading}`;
+		const sectionTokens = Math.ceil(
+			countTokensApprox(sectionContent) * SAFETY_MARGIN,
+		);
+		if (tokensUsed + sectionTokens <= contentBudget) {
+			includedIndices.add(i);
+			tokensUsed += sectionTokens;
+		} else {
+			truncatedCount++;
+		}
+	}
+	if (truncatedCount === 0) {
+		contentBudget += truncationWarningTokens;
+	}
+	const includedNumbers = [];
+	const excludedNumbers = [];
+	for (let i = 0; i < flatSections.length; i++) {
+		if (includedIndices.has(i)) {
+			includedNumbers.push(flatSections[i].number);
+		} else {
+			excludedNumbers.push(flatSections[i].number);
+		}
+	}
+	let tokensShown = 0;
+	for (const idx of includedIndices) {
+		tokensShown += flatSections[idx].section.summaryTokens;
+	}
+	let output = buildOutput(
+		includedIndices,
+		{
+			showWarning: truncatedCount > 0,
+			truncatedCount,
+			includedNumbers,
+			excludedNumbers,
+			tokensShown,
+			tokensTotal: summary.originalTokens,
+		},
+		includeTopics,
+	);
+	let actualTokens = countTokensApprox(output);
+	const sortedIndices = Array.from(includedIndices).sort((a, b) => b - a);
+	let removalIndex = 0;
+	while (actualTokens > maxTokens && removalIndex < sortedIndices.length) {
+		const indexToRemove = sortedIndices[removalIndex];
+		includedIndices.delete(indexToRemove);
+		truncatedCount++;
+		removalIndex++;
+		const removedNumber = flatSections[indexToRemove].number;
+		const includedIdx = includedNumbers.indexOf(removedNumber);
+		if (includedIdx !== -1) {
+			includedNumbers.splice(includedIdx, 1);
+			excludedNumbers.push(removedNumber);
+		}
+		tokensShown -= flatSections[indexToRemove].section.summaryTokens;
+		output = buildOutput(
+			includedIndices,
+			{
+				showWarning: true,
+				truncatedCount,
+				includedNumbers,
+				excludedNumbers,
+				tokensShown,
+				tokensTotal: summary.originalTokens,
+			},
+			includeTopics,
+		);
+		actualTokens = countTokensApprox(output);
+	}
+	if (actualTokens > maxTokens && includeTopics) {
+		includeTopics = false;
+		output = buildOutput(
+			includedIndices,
+			{
+				showWarning: truncatedCount > 0,
+				truncatedCount,
+				includedNumbers,
+				excludedNumbers,
+				tokensShown,
+				tokensTotal: summary.originalTokens,
+			},
+			includeTopics,
+		);
+		actualTokens = countTokensApprox(output);
+	}
+	if (actualTokens > maxTokens && truncatedCount > 0) {
+		output = buildOutput(
+			includedIndices,
+			{
+				showWarning: false,
+				truncatedCount,
+				includedNumbers,
+				excludedNumbers,
+				tokensShown,
+				tokensTotal: summary.originalTokens,
+			},
+			includeTopics,
+		);
+		actualTokens = countTokensApprox(output);
+	}
+	return output;
+};
+var formatAssembledContext = (context) => {
+	const lines = [];
+	lines.push("# Context Assembly");
+	lines.push(`Total tokens: ${context.totalTokens}/${context.budget}`);
+	lines.push(`Sources: ${context.sources.length}`);
+	lines.push("");
+	for (const source of context.sources) {
+		lines.push("---");
+		lines.push("");
+		lines.push(source.content);
+	}
+	if (context.overflow.length > 0) {
+		lines.push("---");
+		lines.push("");
+		lines.push("## Overflow (not included due to budget)");
+		for (const overflowPath of context.overflow) {
+			lines.push(`- ${overflowPath}`);
+		}
+	}
+	return lines.join("\n");
+};
+
+import { Effect } from "effect";
+// src/summarize/summarizer.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+
+var TOKEN_BUDGETS = {
+	brief: 100,
+	summary: 500,
+	full: Infinity,
+};
+var MIN_SENTENCE_LENGTH = 10;
+var SENTENCE_SCORE_DEFINITION = 2;
+var SENTENCE_SCORE_PROPER_START = 1;
+var SENTENCE_SCORE_MEDIUM_LENGTH = 1;
+var SENTENCE_SCORE_EMPHASIS = 1;
+var SENTENCE_LENGTH_MIN = 50;
+var SENTENCE_LENGTH_MAX = 200;
+var SUMMARY_COMPRESSION_RATIO = 0.3;
+var MIN_SECTION_TOKENS = 20;
+var MIN_SUMMARY_SENTENCES = 2;
+var TOKENS_PER_SENTENCE_ESTIMATE = 30;
+var MIN_TOPIC_LENGTH = 2;
+var MAX_TOPIC_LENGTH = 50;
+var MAX_TOPICS = 10;
+var MIN_PARTIAL_BUDGET = 50;
+var extractKeyPoints = (content, maxSentences) => {
+	const sentences = content
+		.replace(/\n+/g, " ")
+		.split(/(?<=[.!?])\s+/)
+		.filter((s) => s.trim().length > MIN_SENTENCE_LENGTH);
+	if (sentences.length <= maxSentences) {
+		return sentences;
+	}
+	const scored = sentences.map((s) => {
+		let score = 0;
+		if (s.includes(":")) score += SENTENCE_SCORE_DEFINITION;
+		if (/^[A-Z]/.test(s)) score += SENTENCE_SCORE_PROPER_START;
+		if (s.length > SENTENCE_LENGTH_MIN && s.length < SENTENCE_LENGTH_MAX)
+			score += SENTENCE_SCORE_MEDIUM_LENGTH;
+		if (/\*\*|`/.test(s)) score += SENTENCE_SCORE_EMPHASIS;
+		return { sentence: s, score };
+	});
+	scored.sort((a, b) => b.score - a.score);
+	return scored.slice(0, maxSentences).map((s) => s.sentence);
+};
+var summarizeSection = (section, level) => {
+	const originalTokens = section.metadata.tokenCount;
+	const children = section.children.map((child) =>
+		summarizeSection(child, level),
+	);
+	const targetTokens = Math.min(
+		TOKEN_BUDGETS[level],
+		Math.max(originalTokens * SUMMARY_COMPRESSION_RATIO, MIN_SECTION_TOKENS),
+	);
+	let summary;
+	if (level === "full" || originalTokens <= targetTokens) {
+		summary = section.plainText;
+	} else if (level === "brief") {
+		const meta = [];
+		if (section.metadata.hasCode) meta.push("code");
+		if (section.metadata.hasList) meta.push("list");
+		if (section.metadata.hasTable) meta.push("table");
+		summary = meta.length > 0 ? `[${meta.join(", ")}]` : "";
+	} else {
+		const maxSentences = Math.max(
+			MIN_SUMMARY_SENTENCES,
+			Math.floor(targetTokens / TOKENS_PER_SENTENCE_ESTIMATE),
+		);
+		const keyPoints = extractKeyPoints(section.plainText, maxSentences);
+		if (keyPoints.length > 0) {
+			summary = keyPoints.join(" ");
+		} else {
+			const words = section.plainText.split(/\s+/).slice(0, targetTokens);
+			summary =
+				words.join(" ") +
+				(words.length < section.plainText.split(/\s+/).length ? "..." : "");
+		}
+	}
+	const summaryTokens = countTokensApprox(summary);
+	return {
+		heading: section.heading,
+		level: section.level,
+		originalTokens,
+		summaryTokens,
+		summary,
+		children,
+		hasCode: section.metadata.hasCode,
+		hasList: section.metadata.hasList,
+		hasTable: section.metadata.hasTable,
+	};
+};
+var extractTopics = (document) => {
+	const topics = /* @__PURE__ */ new Set();
+	const processSection = (section) => {
+		const cleanHeading = section.heading
+			.replace(/[:#\-_]/g, " ")
+			.trim()
+			.toLowerCase();
+		if (
+			cleanHeading.length > MIN_TOPIC_LENGTH &&
+			cleanHeading.length < MAX_TOPIC_LENGTH
+		) {
+			topics.add(cleanHeading);
+		}
+		for (const child of section.children) {
+			processSection(child);
+		}
+	};
+	for (const section of document.sections) {
+		processSection(section);
+	}
+	const frontmatter = document.frontmatter;
+	if (frontmatter.tags && Array.isArray(frontmatter.tags)) {
+		for (const tag of frontmatter.tags) {
+			if (typeof tag === "string") {
+				topics.add(tag.toLowerCase());
+			}
+		}
+	}
+	return Array.from(topics).slice(0, MAX_TOPICS);
+};
+var summarizeDocument = (document, options = {}) => {
+	const level = options.level ?? "summary";
+	const maxTokens = options.maxTokens ?? TOKEN_BUDGETS[level];
+	const allSections = document.sections.map((s) => summarizeSection(s, level));
+	const originalTokens = document.metadata.tokenCount;
+	let totalSummaryTokens = 0;
+	const flatSections = [];
+	const flattenWithTokens = (section) => {
+		flatSections.push(section);
+		totalSummaryTokens += section.summaryTokens;
+		for (const child of section.children) {
+			flattenWithTokens(child);
+		}
+	};
+	for (const section of allSections) {
+		flattenWithTokens(section);
+	}
+	const topics = extractTopics(document);
+	const headerTemplate = `# ${document.title}
+Path: ${document.path}
+Tokens: 9999 (99% reduction from ${document.metadata.tokenCount})
+`;
+	const topicsLine =
+		topics.length > 0
+			? `
+**Topics:** ${topics.join(", ")}
+`
+			: "";
+	const truncationWarning =
+		"\n\u26A0\uFE0F TRUNCATED: 999 sections omitted to fit token budget";
+	const baseOverhead = countTokensApprox(
+		headerTemplate + topicsLine + truncationWarning,
+	);
+	const formattingOverhead = Math.ceil(baseOverhead * 1.2) + 20;
+	const contentBudget = maxTokens - formattingOverhead;
+	let truncated = false;
+	let truncatedCount = 0;
+	let sections;
+	let summaryTokens;
+	if (totalSummaryTokens > contentBudget && contentBudget > 0) {
+		let tokensUsed = 0;
+		const truncateSections = (sectionList) => {
+			const result2 = [];
+			for (const section of sectionList) {
+				const sectionOwnTokens = section.summaryTokens;
+				const fitsInBudget = tokensUsed + sectionOwnTokens <= contentBudget;
+				if (fitsInBudget) {
+					tokensUsed += sectionOwnTokens;
+					const truncatedChildren = truncateSections(section.children);
+					result2.push({
+						...section,
+						children: truncatedChildren,
+					});
+				} else {
+					truncatedCount++;
+					const rescuedChildren = truncateSections(section.children);
+					result2.push(...rescuedChildren);
+				}
+			}
+			return result2;
+		};
+		sections = truncateSections(allSections);
+		summaryTokens = tokensUsed;
+		truncated = truncatedCount > 0;
+	} else {
+		sections = allSections;
+		summaryTokens = totalSummaryTokens;
+	}
+	const compressionRatio =
+		originalTokens > 0 ? 1 - summaryTokens / originalTokens : 0;
+	const result = {
+		path: document.path,
+		title: document.title,
+		originalTokens,
+		summaryTokens,
+		compressionRatio,
+		sections,
+		keyTopics: topics,
+	};
+	if (truncated) {
+		return {
+			...result,
+			truncated: true,
+			truncatedCount,
+		};
+	}
+	return result;
+};
+var summarizeFile = (filePath, options = {}) =>
+	Effect.gen(function* () {
+		const document = yield* parseFile(filePath);
+		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);
+			const summaryResult = yield* summarizeFile(resolvedPath, {
+				level,
+				maxTokens: perSourceBudget,
+			}).pipe(
+				Effect.map((s) => s),
+				// Log error for observability before gracefully degrading
+				Effect.tapError((error) =>
+					Effect.logError(`Failed to summarize ${sourcePath}`, error),
+				),
+				// Note: catchAll intentional for batch processing - individual file
+				// failures add to overflow instead of stopping assembly
+				Effect.catchAll(() => Effect.succeed(null)),
+			);
+			if (!summaryResult) {
+				overflow.push(sourcePath);
+				continue;
+			}
+			const summary = summaryResult;
+			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,
+					}).pipe(
+						Effect.map((s) => s),
+						// Log error for observability before gracefully degrading
+						Effect.tapError((error) =>
+							Effect.logError(
+								`Failed to create brief summary for ${sourcePath}`,
+								error,
+							),
+						),
+						Effect.catchAll(() => Effect.succeed(null)),
+					);
+					if (briefSummary) {
+						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));
+					}
+				} else {
+					overflow.push(path.relative(rootPath, resolvedPath));
+				}
+			}
+		}
+		return {
+			sources,
+			totalTokens,
+			budget,
+			overflow,
+		};
+	});
+
+// src/embeddings/openai-provider.ts
+import { 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";
+
+var PRICING_DATA = {
+	/** Last update date in YYYY-MM format */
+	lastUpdated: "2024-09",
+	/** Source URL for verification */
+	source: "https://platform.openai.com/docs/pricing",
+	/** Prices per 1M tokens by model */
+	prices: {
+		"text-embedding-3-small": 0.02,
+		"text-embedding-3-large": 0.13,
+		"text-embedding-ada-002": 0.1,
+	},
+};
+var checkPricingFreshness = () => {
+	const [year, month] = PRICING_DATA.lastUpdated.split("-").map(Number);
+	if (!year || !month) return null;
+	const lastUpdated = new Date(year, month - 1, 1);
+	const now = /* @__PURE__ */ new Date();
+	const daysSince = Math.floor(
+		(now.getTime() - lastUpdated.getTime()) / (1e3 * 60 * 60 * 24),
+	);
+	if (daysSince > 90) {
+		return `Pricing data is ${daysSince} days old. May not reflect current rates.`;
+	}
+	return null;
+};
+var getPricingDate = () => PRICING_DATA.lastUpdated;
+var OpenAIProvider = class _OpenAIProvider {
+	name;
+	dimensions;
+	client;
+	model;
+	batchSize;
+	constructor(apiKey, options = {}) {
+		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;
+	}
+	/**
+	 * Create an OpenAI provider instance.
+	 * Returns an Effect that fails with ApiKeyMissingError if no API key is available.
+	 */
+	static create(options = {}) {
+		const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+		if (!apiKey) {
+			return Effect2.fail(
+				new ApiKeyMissingError({
+					provider: "OpenAI",
+					envVar: "OPENAI_API_KEY",
+				}),
+			);
+		}
+		return Effect2.succeed(new _OpenAIProvider(apiKey, options));
+	}
+	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 ApiKeyInvalidError({
+					provider: "OpenAI",
+					details: error.message,
+				});
+			}
+			throw error;
+		}
+		const pricePerMillion = PRICING_DATA.prices[this.model] ?? 0.02;
+		const cost = (totalTokens / 1e6) * pricePerMillion;
+		return {
+			embeddings: allEmbeddings,
+			tokensUsed: totalTokens,
+			cost,
+		};
+	}
+};
+var createOpenAIProvider = (options) => OpenAIProvider.create(options);
+var wrapEmbedding = (embedPromise) =>
+	Effect2.tryPromise({
+		try: () => embedPromise,
+		catch: (e) => {
+			if (e instanceof ApiKeyInvalidError) {
+				return e;
+			}
+			return new EmbeddingError({
+				reason: "Unknown",
+				message: e instanceof Error ? e.message : String(e),
+				provider: "OpenAI",
+				cause: e,
+			});
+		},
+	});
+
+import { Effect as Effect3 } from "effect";
+// src/embeddings/vector-store.ts
+import * as fs2 from "fs/promises";
+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.try({
+			try: () => {
+				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);
+				}
+			},
+			catch: (e) =>
+				new VectorStoreError({
+					operation: "add",
+					message: e instanceof Error ? e.message : String(e),
+					cause: e,
+				}),
+		});
+	}
+	search(vector, limit, threshold = 0) {
+		return Effect3.try({
+			try: () => {
+				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;
+			},
+			catch: (e) =>
+				new VectorStoreError({
+					operation: "search",
+					message: e instanceof Error ? e.message : String(e),
+					cause: e,
+				}),
+		});
+	}
+	save() {
+		return Effect3.gen(
+			function* () {
+				if (!this.index) {
+					return;
+				}
+				const indexDir = this.getIndexDir();
+				yield* Effect3.tryPromise({
+					try: () => fs2.mkdir(indexDir, { recursive: true }),
+					catch: (e) =>
+						new VectorStoreError({
+							operation: "save",
+							message: `Failed to create directory: ${e instanceof Error ? e.message : String(e)}`,
+							cause: e,
+						}),
+				});
+				yield* Effect3.tryPromise({
+					try: () => this.index.writeIndex(this.getVectorPath()),
+					catch: (e) =>
+						new VectorStoreError({
+							operation: "save",
+							message: `Failed to write index: ${e instanceof Error ? e.message : String(e)}`,
+							cause: e,
+						}),
+				});
+				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.tryPromise({
+					try: () =>
+						fs2.writeFile(this.getMetaPath(), JSON.stringify(meta, null, 2)),
+					catch: (e) =>
+						new VectorStoreError({
+							operation: "save",
+							message: `Failed to write metadata: ${e instanceof Error ? e.message : String(e)}`,
+							cause: e,
+						}),
+				});
+			}.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: () =>
+						new VectorStoreError({
+							operation: "load",
+							message: "Files not found",
+						}),
+				}).pipe(
+					Effect3.catchTag("VectorStoreError", () => Effect3.succeed(false)),
+				);
+				if (!filesExist) {
+					return false;
+				}
+				const metaContent = yield* Effect3.tryPromise({
+					try: () => fs2.readFile(metaPath, "utf-8"),
+					catch: (e) =>
+						new VectorStoreError({
+							operation: "load",
+							message: `Failed to read metadata: ${e instanceof Error ? e.message : String(e)}`,
+							cause: e,
+						}),
+				});
+				const meta = yield* Effect3.try({
+					try: () => JSON.parse(metaContent),
+					catch: (e) =>
+						new VectorStoreError({
+							operation: "load",
+							message: `Failed to parse metadata: ${e instanceof Error ? e.message : String(e)}`,
+							cause: e,
+						}),
+				});
+				if (meta.dimensions !== this.dimensions) {
+					return false;
+				}
+				this.index = new HierarchicalNSW.HierarchicalNSW(
+					"cosine",
+					this.dimensions,
+				);
+				yield* Effect3.tryPromise({
+					try: () => this.index.readIndex(vectorPath),
+					catch: (e) =>
+						new VectorStoreError({
+							operation: "load",
+							message: `Failed to read index: ${e instanceof Error ? e.message : String(e)}`,
+							cause: e,
+						}),
+				});
+				this.entries.clear();
+				this.idToIndex.clear();
+				this.nextIndex = 0;
+				for (const [idxStr, entry] of Object.entries(meta.entries)) {
+					const idx = parseInt(idxStr, 10);
+					this.entries.set(idx, entry);
+					this.idToIndex.set(entry.id, idx);
+					this.nextIndex = Math.max(this.nextIndex, idx + 1);
+				}
+				this.provider = meta.provider;
+				this.totalCost = meta.totalCost;
+				this.totalTokens = meta.totalTokens;
+				return true;
+			}.bind(this),
+		);
+	}
+	getStats() {
+		return {
+			count: this.entries.size,
+			dimensions: this.dimensions,
+			provider: this.provider,
+			totalCost: this.totalCost,
+			totalTokens: this.totalTokens,
+		};
+	}
+	setProvider(name) {
+		this.provider = name;
+	}
+	addCost(cost, tokens) {
+		this.totalCost += cost;
+		this.totalTokens += tokens;
+	}
+};
+var createVectorStore = (rootPath, dimensions) =>
+	new HnswVectorStore(rootPath, dimensions);
+
+// src/embeddings/semantic-search.ts
+var generateEmbeddingText = (
+	section,
+	content,
+	documentTitle,
+	parentHeading,
+) => {
+	const parts = [];
+	parts.push(`# ${section.heading}`);
+	if (parentHeading) {
+		parts.push(`Parent section: ${parentHeading}`);
+	}
+	parts.push(`Document: ${documentTitle}`);
+	parts.push("");
+	parts.push(content);
+	return parts.join("\n");
+};
+var EMBEDDING_PRICE_PER_MILLION =
+	PRICING_DATA.prices["text-embedding-3-small"] ?? 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 IndexNotFoundError({ path: resolvedRoot }),
+			);
+		}
+		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 IndexNotFoundError({ path: resolvedRoot }),
+			);
+		}
+		const provider = options.provider ?? (yield* createOpenAIProvider());
+		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);
+			const fileContentResult = yield* Effect4.promise(() =>
+				fs3.readFile(filePath, "utf-8"),
+			).pipe(
+				Effect4.map((content) => ({ ok: true, content })),
+				Effect4.catchAll(() => Effect4.succeed({ ok: false, content: "" })),
+			);
+			if (!fileContentResult.ok) {
+				yield* Effect4.logWarning(`Skipping file (cannot read): ${docPath}`);
+				continue;
+			}
+			filesProcessed++;
+			const lines = fileContentResult.content.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* wrapEmbedding(provider.embed(texts));
+		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* createOpenAIProvider();
+		const dimensions = provider.dimensions;
+		const vectorStore = createVectorStore(resolvedRoot, dimensions);
+		const loaded = yield* vectorStore.load();
+		if (!loaded) {
+			return yield* Effect4.fail(
+				new EmbeddingsNotFoundError({ path: resolvedRoot }),
+			);
+		}
+		const queryResult = yield* wrapEmbedding(provider.embed([query]));
+		const queryVector = queryResult.embeddings[0];
+		if (!queryVector) {
+			return yield* Effect4.fail(
+				new EmbeddingError({
+					reason: "Unknown",
+					message: "Failed to generate query embedding",
+					provider: "OpenAI",
+				}),
+			);
+		}
+		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";
+
+// src/search/query-parser.ts
+var tokenize = (query) => {
+	const tokens = [];
+	let i = 0;
+	while (i < query.length) {
+		if (/\s/.test(query[i])) {
+			i++;
+			continue;
+		}
+		if (query[i] === '"') {
+			const start = i + 1;
+			i++;
+			while (i < query.length && query[i] !== '"') {
+				i++;
+			}
+			const value = query.slice(start, i);
+			tokens.push({ type: "PHRASE", value });
+			i++;
+			continue;
+		}
+		if (query[i] === "(") {
+			tokens.push({ type: "LPAREN", value: "(" });
+			i++;
+			continue;
+		}
+		if (query[i] === ")") {
+			tokens.push({ type: "RPAREN", value: ")" });
+			i++;
+			continue;
+		}
+		const wordMatch = query.slice(i).match(/^[^\s()"]+/);
+		if (wordMatch) {
+			const word = wordMatch[0];
+			const upperWord = word.toUpperCase();
+			if (upperWord === "AND") {
+				tokens.push({ type: "AND", value: "AND" });
+			} else if (upperWord === "OR") {
+				tokens.push({ type: "OR", value: "OR" });
+			} else if (upperWord === "NOT") {
+				tokens.push({ type: "NOT", value: "NOT" });
+			} else {
+				tokens.push({ type: "TERM", value: word });
+			}
+			i += word.length;
+			continue;
+		}
+		i++;
+	}
+	return tokens;
+};
+var Parser = class {
+	tokens;
+	pos = 0;
+	terms = [];
+	phrases = [];
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	current() {
+		return this.tokens[this.pos];
+	}
+	advance() {
+		return this.tokens[this.pos++];
+	}
+	match(type) {
+		if (this.current()?.type === type) {
+			this.advance();
+			return true;
+		}
+		return false;
+	}
+	parse() {
+		if (this.tokens.length === 0) {
+			return null;
+		}
+		return this.parseExpr();
+	}
+	parseExpr() {
+		let left = this.parseAndExpr();
+		while (this.match("OR")) {
+			const right = this.parseAndExpr();
+			left = { type: "or", left, right };
+		}
+		return left;
+	}
+	parseAndExpr() {
+		let left = this.parseNotExpr();
+		while (this.match("AND") || this.isImplicitAnd()) {
+			const right = this.parseNotExpr();
+			left = { type: "and", left, right };
+		}
+		return left;
+	}
+	isImplicitAnd() {
+		const tok = this.current();
+		return (
+			tok?.type === "TERM" ||
+			tok?.type === "PHRASE" ||
+			tok?.type === "NOT" ||
+			tok?.type === "LPAREN"
+		);
+	}
+	parseNotExpr() {
+		if (this.match("NOT")) {
+			const operand = this.parseNotExpr();
+			return { type: "not", operand };
+		}
+		return this.parsePrimary();
+	}
+	parsePrimary() {
+		const tok = this.current();
+		if (this.match("LPAREN")) {
+			const expr = this.parseExpr();
+			this.match("RPAREN");
+			return expr;
+		}
+		if (tok?.type === "PHRASE") {
+			this.advance();
+			this.phrases.push(tok.value);
+			return { type: "phrase", value: tok.value };
+		}
+		if (tok?.type === "TERM") {
+			this.advance();
+			this.terms.push(tok.value);
+			return { type: "term", value: tok.value };
+		}
+		return { type: "term", value: "" };
+	}
+};
+var parseQuery = (query) => {
+	const tokens = tokenize(query);
+	if (tokens.length === 0) {
+		return null;
+	}
+	const parser = new Parser(tokens);
+	const ast = parser.parse();
+	if (!ast) {
+		return null;
+	}
+	return {
+		ast,
+		terms: parser.terms,
+		phrases: parser.phrases,
+	};
+};
+var isAdvancedQuery = (query) => {
+	const tokens = tokenize(query);
+	return tokens.some(
+		(t) =>
+			t.type === "AND" ||
+			t.type === "OR" ||
+			t.type === "NOT" ||
+			t.type === "PHRASE" ||
+			t.type === "LPAREN",
+	);
+};
+var evaluateQuery = (ast, text) => {
+	const lowerText = text.toLowerCase();
+	const evaluate = (node) => {
+		switch (node.type) {
+			case "term": {
+				if (!node.value) return true;
+				return lowerText.includes(node.value.toLowerCase());
+			}
+			case "phrase": {
+				return lowerText.includes(node.value.toLowerCase());
+			}
+			case "and": {
+				return evaluate(node.left) && evaluate(node.right);
+			}
+			case "or": {
+				return evaluate(node.left) || evaluate(node.right);
+			}
+			case "not": {
+				return !evaluate(node.operand);
+			}
+		}
+	};
+	return evaluate(ast);
+};
+var buildHighlightPattern = (parsed) => {
+	const patterns = [];
+	const escapeChars = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	for (const term of parsed.terms) {
+		if (term) {
+			patterns.push(`\\b${escapeChars(term)}\\b`);
+		}
+	}
+	for (const phrase of parsed.phrases) {
+		if (phrase) {
+			patterns.push(escapeChars(phrase));
+		}
+	}
+	if (patterns.length === 0) {
+		return /.^/;
+	}
+	return new RegExp(patterns.join("|"), "gi");
+};
+
+// src/search/searcher.ts
+var matchPath = (filePath, pattern) => {
+	const regexPattern = pattern
+		.replace(/\./g, "\\.")
+		.replace(/\*/g, ".*")
+		.replace(/\?/g, ".");
+	const regex = new RegExp(`^${regexPattern}$`, "i");
+	return regex.test(filePath);
+};
+var search = (rootPath, options = {}) =>
+	Effect5.gen(function* () {
+		const storage = createStorage(rootPath);
+		const docIndex = yield* loadDocumentIndex(storage);
+		const sectionIndex = yield* loadSectionIndex(storage);
+		if (!docIndex || !sectionIndex) {
+			return [];
+		}
+		const results = [];
+		const headingRegex = options.heading
+			? new RegExp(options.heading, "i")
+			: null;
+		for (const section of Object.values(sectionIndex.sections)) {
+			if (headingRegex && !headingRegex.test(section.heading)) {
+				continue;
+			}
+			if (
+				options.pathPattern &&
+				!matchPath(section.documentPath, options.pathPattern)
+			) {
+				continue;
+			}
+			if (options.hasCode !== void 0 && section.hasCode !== options.hasCode) {
+				continue;
+			}
+			if (options.hasList !== void 0 && section.hasList !== options.hasList) {
+				continue;
+			}
+			if (
+				options.hasTable !== void 0 &&
+				section.hasTable !== options.hasTable
+			) {
+				continue;
+			}
+			if (options.minLevel !== void 0 && section.level < options.minLevel) {
+				continue;
+			}
+			if (options.maxLevel !== void 0 && section.level > options.maxLevel) {
+				continue;
+			}
+			const document = docIndex.documents[section.documentPath];
+			if (document) {
+				results.push({ section, document });
+			}
+			if (options.limit !== void 0 && results.length >= options.limit) {
+				break;
+			}
+		}
+		return results;
+	});
+var searchContent = (rootPath, options = {}) =>
+	Effect5.gen(function* () {
+		const storage = createStorage(rootPath);
+		const docIndex = yield* loadDocumentIndex(storage);
+		const sectionIndex = yield* loadSectionIndex(storage);
+		if (!docIndex || !sectionIndex) {
+			return [];
+		}
+		let parsedQuery = null;
+		let contentRegex = null;
+		let highlightRegex = null;
+		if (options.content) {
+			if (isAdvancedQuery(options.content)) {
+				parsedQuery = parseQuery(options.content);
+				if (parsedQuery) {
+					highlightRegex = buildHighlightPattern(parsedQuery);
+				}
+			} else {
+				contentRegex = new RegExp(options.content, "gi");
+				highlightRegex = contentRegex;
+			}
+		}
+		const headingRegex = options.heading
+			? new RegExp(options.heading, "i")
+			: null;
+		const results = [];
+		const sectionsByDoc = {};
+		for (const section of Object.values(sectionIndex.sections)) {
+			const docSections = sectionsByDoc[section.documentPath];
+			if (docSections) {
+				docSections.push(section);
+			} else {
+				sectionsByDoc[section.documentPath] = [section];
+			}
+		}
+		for (const [docPath, sections] of Object.entries(sectionsByDoc)) {
+			if (options.pathPattern && !matchPath(docPath, options.pathPattern)) {
+				continue;
+			}
+			const document = docIndex.documents[docPath];
+			if (!document) continue;
+			let fileContent = null;
+			let fileLines = [];
+			if (parsedQuery || contentRegex) {
+				const filePath = path4.join(storage.rootPath, docPath);
+				try {
+					fileContent = yield* Effect5.promise(() =>
+						fs4.readFile(filePath, "utf-8"),
+					);
+					fileLines = fileContent.split("\n");
+				} catch {
+					continue;
+				}
+			}
+			for (const section of sections) {
+				if (headingRegex && !headingRegex.test(section.heading)) {
+					continue;
+				}
+				if (options.hasCode !== void 0 && section.hasCode !== options.hasCode) {
+					continue;
+				}
+				if (options.hasList !== void 0 && section.hasList !== options.hasList) {
+					continue;
+				}
+				if (
+					options.hasTable !== void 0 &&
+					section.hasTable !== options.hasTable
+				) {
+					continue;
+				}
+				if (options.minLevel !== void 0 && section.level < options.minLevel) {
+					continue;
+				}
+				if (options.maxLevel !== void 0 && section.level > options.maxLevel) {
+					continue;
+				}
+				if ((parsedQuery || contentRegex) && fileContent) {
+					const sectionLines = fileLines.slice(
+						section.startLine - 1,
+						section.endLine,
+					);
+					const sectionContent = sectionLines.join("\n");
+					if (parsedQuery) {
+						if (!evaluateQuery(parsedQuery.ast, sectionContent)) {
+							continue;
+						}
+					}
+					const matches = [];
+					const searchRegex = contentRegex || highlightRegex;
+					const contextBefore = options.contextBefore ?? 1;
+					const contextAfter = options.contextAfter ?? 1;
+					if (searchRegex) {
+						for (let i = 0; i < sectionLines.length; i++) {
+							const line = sectionLines[i];
+							if (line && searchRegex.test(line)) {
+								searchRegex.lastIndex = 0;
+								const absoluteLineNum = section.startLine + i;
+								const snippetStart = Math.max(0, i - contextBefore);
+								const snippetEnd = Math.min(
+									sectionLines.length,
+									i + contextAfter + 1,
+								);
+								const snippetLines = sectionLines.slice(
+									snippetStart,
+									snippetEnd,
+								);
+								const snippet = snippetLines.join("\n");
+								const contextLines = [];
+								for (let j = snippetStart; j < snippetEnd; j++) {
+									const ctxLine = sectionLines[j];
+									if (ctxLine !== void 0) {
+										contextLines.push({
+											lineNumber: section.startLine + j,
+											line: ctxLine,
+											isMatch: j === i,
+										});
+									}
+								}
+								matches.push({
+									lineNumber: absoluteLineNum,
+									line,
+									snippet,
+									contextLines,
+								});
+							}
+						}
+					}
+					if (parsedQuery || matches.length > 0) {
+						const result = {
+							section,
+							document,
+							sectionContent,
+						};
+						if (matches.length > 0) {
+							results.push({ ...result, matches });
+						} else {
+							results.push(result);
+						}
+						if (options.limit !== void 0 && results.length >= options.limit) {
+							return results;
+						}
+					}
+				} else if (!parsedQuery && !contentRegex) {
+					results.push({ section, document });
+					if (options.limit !== void 0 && results.length >= options.limit) {
+						return results;
+					}
+				}
+			}
+		}
+		return results;
+	});
+
+export {
+	formatSummary,
+	formatAssembledContext,
+	summarizeFile,
+	assembleContext,
+	checkPricingFreshness,
+	getPricingDate,
+	estimateEmbeddingCost,
+	buildEmbeddings,
+	semanticSearch,
+	getEmbeddingStats,
+	isAdvancedQuery,
+	search,
+	searchContent,
+};