mdcontext 0.0.1 → 0.2.0

package/dist/chunk-23UPXDNL.js

@@ -0,0 +1,3044 @@
+import {
+  ApiKeyInvalidError,
+  ApiKeyMissingError,
+  ConfigError,
+  DimensionMismatchError,
+  EmbeddingError,
+  EmbeddingsNotFoundError,
+  INDEX_DIR,
+  IndexNotFoundError,
+  VectorStoreError,
+  countTokensApprox,
+  createStorage,
+  loadDocumentIndex,
+  loadSectionIndex,
+  parseFile
+} from "./chunk-2W7MO2DL.js";
+import {
+  MdContextConfig,
+  defaultConfig
+} from "./chunk-7TOWB2XB.js";
+
+// src/config/precedence.ts
+import { ConfigProvider as ConfigProvider2, Effect as Effect2 } from "effect";
+
+// src/config/file-provider.ts
+import * as fs from "fs";
+import * as path from "path";
+import { ConfigProvider, Effect } from "effect";
+var CONFIG_FILE_NAMES = [
+  "mdcontext.config.ts",
+  "mdcontext.config.js",
+  "mdcontext.config.mjs",
+  "mdcontext.config.json",
+  ".mdcontextrc",
+  ".mdcontextrc.json"
+];
+var findConfigFile = (startDir) => {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const configPath = path.join(currentDir, fileName);
+      if (fs.existsSync(configPath)) {
+        const format = getConfigFormat(fileName);
+        return { path: configPath, format };
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+};
+var getConfigFormat = (fileName) => {
+  if (fileName.endsWith(".ts")) return "ts";
+  if (fileName.endsWith(".js") || fileName.endsWith(".mjs")) return "js";
+  return "json";
+};
+var loadJsonConfig = (filePath) => Effect.try({
+  try: () => {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  },
+  catch: (error) => new ConfigError({
+    field: "configFile",
+    message: `Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+    cause: error
+  })
+});
+var loadJsConfig = (filePath) => Effect.tryPromise({
+  try: async () => {
+    const fileUrl = `file://${filePath}`;
+    const module = await import(fileUrl);
+    const config = module.default ?? module.config;
+    if (!config || typeof config !== "object") {
+      throw new Error(
+        'Config file must export a default object or named "config" export'
+      );
+    }
+    return config;
+  },
+  catch: (error) => new ConfigError({
+    field: "configFile",
+    message: `Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
+    cause: error
+  })
+});
+var loadConfigFromFile = (filePath, format) => {
+  switch (format) {
+    case "json":
+      return loadJsonConfig(filePath);
+    case "ts":
+    case "js":
+      return loadJsConfig(filePath);
+  }
+};
+var loadConfigFile = (startDir) => Effect.gen(function* () {
+  const found = findConfigFile(startDir);
+  if (!found) {
+    return {
+      found: false,
+      searched: CONFIG_FILE_NAMES.map((name) => path.join(startDir, name))
+    };
+  }
+  const config = yield* loadConfigFromFile(found.path, found.format);
+  return {
+    found: true,
+    path: found.path,
+    config
+  };
+});
+var loadConfigFromPath = (configPath) => Effect.gen(function* () {
+  const resolvedPath = path.resolve(configPath);
+  if (!fs.existsSync(resolvedPath)) {
+    return yield* Effect.fail(
+      new ConfigError({
+        field: "configFile",
+        message: `Config file not found: ${resolvedPath}`
+      })
+    );
+  }
+  const format = getConfigFormat(path.basename(configPath));
+  return yield* loadConfigFromFile(resolvedPath, format);
+});
+
+// src/config/precedence.ts
+var flattenConfig = (config, prefix = "") => {
+  const result = /* @__PURE__ */ new Map();
+  const flatten = (obj, currentPrefix) => {
+    if (obj === null || obj === void 0) {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      result.set(currentPrefix, obj.join(","));
+      return;
+    }
+    if (typeof obj === "object") {
+      for (const [key, value] of Object.entries(obj)) {
+        const newKey = currentPrefix ? `${currentPrefix}.${key}` : key;
+        flatten(value, newKey);
+      }
+      return;
+    }
+    result.set(currentPrefix, String(obj));
+  };
+  flatten(config, prefix);
+  return result;
+};
+var ENV_SEQ_DELIM = ",";
+var CONFIG_SCHEMA_KEYS = {
+  index: [
+    "maxDepth",
+    "excludePatterns",
+    "fileExtensions",
+    "followSymlinks",
+    "indexDir"
+  ],
+  search: [
+    "defaultLimit",
+    "maxLimit",
+    "minSimilarity",
+    "includeSnippets",
+    "snippetLength",
+    "autoIndexThreshold"
+  ],
+  embeddings: [
+    "provider",
+    "baseURL",
+    "model",
+    "dimensions",
+    "batchSize",
+    "maxRetries",
+    "retryDelayMs",
+    "timeoutMs",
+    "apiKey"
+  ],
+  summarization: [
+    "briefTokenBudget",
+    "summaryTokenBudget",
+    "compressionRatio",
+    "minSectionTokens",
+    "maxTopics",
+    "minPartialBudget"
+  ],
+  output: ["format", "color", "prettyJson", "verbose", "debug"],
+  paths: ["root", "configFile", "cacheDir"]
+};
+var generateEnvKeyMapping = () => {
+  const mapping = {};
+  for (const [section, keys] of Object.entries(CONFIG_SCHEMA_KEYS)) {
+    for (const key of keys) {
+      const envKey = `${section}_${key}`.toLowerCase();
+      const configKey = `${section}.${key}`;
+      mapping[envKey] = configKey;
+    }
+  }
+  return mapping;
+};
+var ENV_KEY_MAPPING = generateEnvKeyMapping();
+var readEnvConfig = (prefix = "MDCONTEXT") => {
+  const result = /* @__PURE__ */ new Map();
+  const prefixWithUnderscore = `${prefix}_`;
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith(prefixWithUnderscore) && value !== void 0) {
+      const envKey = key.slice(prefixWithUnderscore.length).toLowerCase();
+      const configKey = ENV_KEY_MAPPING[envKey];
+      if (configKey) {
+        result.set(configKey, value);
+      }
+    }
+  }
+  return result;
+};
+var createConfigProvider = (options = {}) => Effect2.gen(function* () {
+  const {
+    cliOverrides,
+    configPath,
+    workingDir = process.cwd(),
+    envPrefix = "MDCONTEXT",
+    skipConfigFile = false,
+    skipEnv = false
+  } = options;
+  const mergedMap = /* @__PURE__ */ new Map();
+  if (!skipConfigFile) {
+    let fileConfig;
+    if (configPath) {
+      fileConfig = yield* loadConfigFromPath(configPath);
+    } else {
+      const result = yield* loadConfigFile(workingDir);
+      if (result.found) {
+        fileConfig = result.config;
+      }
+    }
+    if (fileConfig) {
+      const flattened = flattenConfig(fileConfig);
+      for (const [k, v] of flattened) {
+        mergedMap.set(k, v);
+      }
+    }
+  }
+  if (!skipEnv) {
+    const envConfig = readEnvConfig(envPrefix);
+    for (const [k, v] of envConfig) {
+      mergedMap.set(k, v);
+    }
+  }
+  if (cliOverrides && Object.keys(cliOverrides).length > 0) {
+    const flattened = flattenConfig(cliOverrides);
+    for (const [k, v] of flattened) {
+      mergedMap.set(k, v);
+    }
+  }
+  return ConfigProvider2.fromMap(mergedMap, {
+    pathDelim: ".",
+    seqDelim: ENV_SEQ_DELIM
+  });
+});
+var createConfigProviderSync = (options = {}) => {
+  const {
+    cliOverrides,
+    fileConfig,
+    envPrefix = "MDCONTEXT",
+    skipConfigFile = false,
+    skipEnv = false
+  } = options;
+  const mergedMap = /* @__PURE__ */ new Map();
+  if (!skipConfigFile && fileConfig) {
+    const flattened = flattenConfig(fileConfig);
+    for (const [k, v] of flattened) {
+      mergedMap.set(k, v);
+    }
+  }
+  if (!skipEnv) {
+    const envConfig = readEnvConfig(envPrefix);
+    for (const [k, v] of envConfig) {
+      mergedMap.set(k, v);
+    }
+  }
+  if (cliOverrides && Object.keys(cliOverrides).length > 0) {
+    const flattened = flattenConfig(cliOverrides);
+    for (const [k, v] of flattened) {
+      mergedMap.set(k, v);
+    }
+  }
+  return ConfigProvider2.fromMap(mergedMap, {
+    pathDelim: ".",
+    seqDelim: ENV_SEQ_DELIM
+  });
+};
+
+// src/config/service.ts
+import { Context, Effect as Effect3, Layer } from "effect";
+var ConfigService = class extends Context.Tag("ConfigService")() {
+};
+var ConfigServiceLive = Layer.effect(ConfigService, MdContextConfig);
+var makeConfigLayer = (config) => Layer.succeed(ConfigService, config);
+var ConfigServiceDefault = makeConfigLayer(defaultConfig);
+
+// src/config/testing.ts
+import { Effect as Effect4, Layer as Layer2 } from "effect";
+var TestConfigLayer = Layer2.succeed(
+  ConfigService,
+  defaultConfig
+);
+
+// src/summarize/formatters.ts
+var formatSummary = (summary, options = {}) => {
+  const maxTokens = options.maxTokens;
+  const flatSections = [];
+  const collectSections = (section, depth = 0, parentNumber = "", index = 0) => {
+    const number = parentNumber ? `${parentNumber}.${index + 1}` : `${index + 1}`;
+    flatSections.push({ section, depth, number });
+    section.children.forEach((child, i) => {
+      collectSections(child, depth + 1, number, i);
+    });
+  };
+  summary.sections.forEach((section, i) => {
+    collectSections(section, 0, "", i);
+  });
+  const buildOutput = (includedSectionIndices, truncationInfo, includeTopics2) => {
+    const lines = [];
+    if (truncationInfo.showWarning && truncationInfo.truncatedCount > 0 && truncationInfo.tokensTotal > 0) {
+      const pct = Math.round(
+        truncationInfo.tokensShown / truncationInfo.tokensTotal * 100
+      );
+      lines.push(
+        `\u26A0\uFE0F Truncated: Showing ~${truncationInfo.tokensShown}/${truncationInfo.tokensTotal} tokens (${pct}%)`
+      );
+      if (truncationInfo.includedNumbers.length > 0) {
+        const includedDisplay = truncationInfo.includedNumbers.length <= 6 ? truncationInfo.includedNumbers.join(", ") : truncationInfo.includedNumbers.slice(0, 5).join(", ") + `, ... (+${truncationInfo.includedNumbers.length - 5} more)`;
+        lines.push(`Sections included: ${includedDisplay}`);
+      }
+      if (truncationInfo.excludedNumbers.length > 0) {
+        const excludedDisplay = truncationInfo.excludedNumbers.length <= 6 ? truncationInfo.excludedNumbers.join(", ") : truncationInfo.excludedNumbers.slice(0, 5).join(", ") + `, ... (+${truncationInfo.excludedNumbers.length - 5} more)`;
+        lines.push(`Sections excluded: ${excludedDisplay}`);
+      }
+      lines.push(
+        "Use --full for complete content or --section to target specific sections."
+      );
+      lines.push("");
+    }
+    lines.push(`# ${summary.title}`);
+    lines.push(`Path: ${summary.path}`);
+    const tokenLineIndex = lines.length;
+    lines.push("PLACEHOLDER");
+    lines.push("");
+    const fullTopicsLine2 = summary.keyTopics.length > 0 ? `**Topics:** ${summary.keyTopics.join(", ")}` : "";
+    if (includeTopics2 && fullTopicsLine2) {
+      lines.push(fullTopicsLine2);
+      lines.push("");
+    }
+    const sectionLines = [];
+    for (let i = 0; i < flatSections.length; i++) {
+      if (!includedSectionIndices.has(i)) continue;
+      const { section, depth } = flatSections[i];
+      const indent = "  ".repeat(depth);
+      const prefix = "#".repeat(section.level);
+      sectionLines.push(`${indent}${prefix} ${section.heading}`);
+      if (section.summary) {
+        sectionLines.push(`${indent}${section.summary}`);
+      }
+    }
+    lines.push(sectionLines.join("\n"));
+    const tempOutput = lines.join("\n");
+    const tokensWithoutLine = countTokensApprox(
+      tempOutput.replace("PLACEHOLDER", "")
+    );
+    let estimatedTotal = tokensWithoutLine + 8;
+    for (let iter = 0; iter < 3; iter++) {
+      const testTokenLine = `Tokens: ${estimatedTotal} (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`;
+      const testOutput = tempOutput.replace("PLACEHOLDER", testTokenLine);
+      const actualTotal = countTokensApprox(testOutput);
+      if (actualTotal === estimatedTotal) break;
+      estimatedTotal = actualTotal;
+    }
+    const finalTokenLine = `Tokens: ${estimatedTotal} (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`;
+    lines[tokenLineIndex] = finalTokenLine;
+    return lines.join("\n");
+  };
+  if (maxTokens === void 0) {
+    const allIndices = new Set(flatSections.map((_, i) => i));
+    const hasPriorTruncation = summary.truncated && summary.truncatedCount;
+    return buildOutput(
+      allIndices,
+      {
+        showWarning: !!hasPriorTruncation,
+        truncatedCount: summary.truncatedCount ?? 0,
+        includedNumbers: flatSections.map((s) => s.number),
+        excludedNumbers: [],
+        tokensShown: summary.summaryTokens,
+        tokensTotal: summary.originalTokens
+      },
+      true
+    );
+  }
+  const includedIndices = /* @__PURE__ */ new Set();
+  let truncatedCount = 0;
+  let includeTopics = true;
+  const SAFETY_MARGIN = 1.15;
+  const minHeaderTemplate = [
+    `# ${summary.title}`,
+    `Path: ${summary.path}`,
+    `Tokens: 9999 (${(summary.compressionRatio * 100).toFixed(0)}% reduction from ${summary.originalTokens})`,
+    "",
+    ""
+  ].join("\n");
+  const minHeaderTokens = Math.ceil(
+    countTokensApprox(minHeaderTemplate) * SAFETY_MARGIN
+  );
+  const fullTopicsLine = summary.keyTopics.length > 0 ? `**Topics:** ${summary.keyTopics.join(", ")}
+` : "";
+  const topicsTokens = fullTopicsLine ? Math.ceil(countTokensApprox(fullTopicsLine) * SAFETY_MARGIN) : 0;
+  const truncationWarningTokens = Math.ceil(
+    countTokensApprox(
+      `\u26A0\uFE0F Truncated: Showing ~9999/9999 tokens (99%)
+Sections included: 1, 2, 3, 4, 5, ... (+99 more)
+Sections excluded: 6, 7, 8, 9, 10, ... (+99 more)
+Use --full for complete content or --section to target specific sections.
+`
+    ) * SAFETY_MARGIN
+  );
+  let headerTokens = minHeaderTokens + topicsTokens;
+  if (headerTokens >= maxTokens) {
+    includeTopics = false;
+    headerTokens = minHeaderTokens;
+  }
+  let contentBudget = maxTokens - headerTokens - truncationWarningTokens;
+  let tokensUsed = 0;
+  for (let i = 0; i < flatSections.length; i++) {
+    const { section, depth } = flatSections[i];
+    const indent = "  ".repeat(depth);
+    const prefix = "#".repeat(section.level);
+    const sectionContent = section.summary ? `${indent}${prefix} ${section.heading}
+${indent}${section.summary}` : `${indent}${prefix} ${section.heading}`;
+    const sectionTokens = Math.ceil(
+      countTokensApprox(sectionContent) * SAFETY_MARGIN
+    );
+    if (tokensUsed + sectionTokens <= contentBudget) {
+      includedIndices.add(i);
+      tokensUsed += sectionTokens;
+    } else {
+      truncatedCount++;
+    }
+  }
+  if (truncatedCount === 0) {
+    contentBudget += truncationWarningTokens;
+  }
+  const includedNumbers = [];
+  const excludedNumbers = [];
+  for (let i = 0; i < flatSections.length; i++) {
+    if (includedIndices.has(i)) {
+      includedNumbers.push(flatSections[i].number);
+    } else {
+      excludedNumbers.push(flatSections[i].number);
+    }
+  }
+  let tokensShown = 0;
+  for (const idx of includedIndices) {
+    tokensShown += flatSections[idx].section.summaryTokens;
+  }
+  let output = buildOutput(
+    includedIndices,
+    {
+      showWarning: truncatedCount > 0,
+      truncatedCount,
+      includedNumbers,
+      excludedNumbers,
+      tokensShown,
+      tokensTotal: summary.originalTokens
+    },
+    includeTopics
+  );
+  let actualTokens = countTokensApprox(output);
+  const sortedIndices = Array.from(includedIndices).sort((a, b) => b - a);
+  let removalIndex = 0;
+  while (actualTokens > maxTokens && removalIndex < sortedIndices.length) {
+    const indexToRemove = sortedIndices[removalIndex];
+    includedIndices.delete(indexToRemove);
+    truncatedCount++;
+    removalIndex++;
+    const removedNumber = flatSections[indexToRemove].number;
+    const includedIdx = includedNumbers.indexOf(removedNumber);
+    if (includedIdx !== -1) {
+      includedNumbers.splice(includedIdx, 1);
+      excludedNumbers.push(removedNumber);
+    }
+    tokensShown -= flatSections[indexToRemove].section.summaryTokens;
+    output = buildOutput(
+      includedIndices,
+      {
+        showWarning: true,
+        truncatedCount,
+        includedNumbers,
+        excludedNumbers,
+        tokensShown,
+        tokensTotal: summary.originalTokens
+      },
+      includeTopics
+    );
+    actualTokens = countTokensApprox(output);
+  }
+  if (actualTokens > maxTokens && includeTopics) {
+    includeTopics = false;
+    output = buildOutput(
+      includedIndices,
+      {
+        showWarning: truncatedCount > 0,
+        truncatedCount,
+        includedNumbers,
+        excludedNumbers,
+        tokensShown,
+        tokensTotal: summary.originalTokens
+      },
+      includeTopics
+    );
+    actualTokens = countTokensApprox(output);
+  }
+  if (actualTokens > maxTokens && truncatedCount > 0) {
+    output = buildOutput(
+      includedIndices,
+      {
+        showWarning: false,
+        truncatedCount,
+        includedNumbers,
+        excludedNumbers,
+        tokensShown,
+        tokensTotal: summary.originalTokens
+      },
+      includeTopics
+    );
+    actualTokens = countTokensApprox(output);
+  }
+  return output;
+};
+var formatAssembledContext = (context) => {
+  const lines = [];
+  lines.push("# Context Assembly");
+  lines.push(`Total tokens: ${context.totalTokens}/${context.budget}`);
+  lines.push(`Sources: ${context.sources.length}`);
+  lines.push("");
+  for (const source of context.sources) {
+    lines.push("---");
+    lines.push("");
+    lines.push(source.content);
+  }
+  if (context.overflow.length > 0) {
+    lines.push("---");
+    lines.push("");
+    lines.push("## Overflow (not included due to budget)");
+    for (const overflowPath of context.overflow) {
+      lines.push(`- ${overflowPath}`);
+    }
+  }
+  return lines.join("\n");
+};
+
+// src/summarize/summarizer.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { Effect as Effect5 } from "effect";
+
+// src/parser/section-filter.ts
+var globMatch = (text, pattern) => {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(text);
+};
+var buildSectionList = (document) => {
+  const result = [];
+  const processSection = (section, prefix, index) => {
+    const number = prefix ? `${prefix}.${index + 1}` : `${index + 1}`;
+    result.push({
+      number,
+      heading: section.heading,
+      level: section.level,
+      tokenCount: section.metadata.tokenCount
+    });
+    section.children.forEach((child, i) => {
+      processSection(child, number, i);
+    });
+  };
+  document.sections.forEach((section, i) => {
+    processSection(section, "", i);
+  });
+  return result;
+};
+var formatSectionList = (sections) => {
+  const lines = [];
+  for (const section of sections) {
+    const depth = (section.number.match(/\./g) || []).length;
+    const indent = "   ".repeat(depth);
+    lines.push(
+      `${indent}${section.number}. ${section.heading} (${section.tokenCount} tokens)`
+    );
+  }
+  return lines.join("\n");
+};
+var matchesSelector = (section, selector) => {
+  if (/^[\d.]+$/.test(selector)) {
+    return section.number === selector;
+  }
+  if (section.heading.toLowerCase() === selector.toLowerCase()) {
+    return true;
+  }
+  if (selector.includes("*") || selector.includes("?")) {
+    return globMatch(section.heading, selector);
+  }
+  return section.heading.toLowerCase().includes(selector.toLowerCase());
+};
+var matchesExclusionPatterns = (section, excludePatterns) => {
+  return excludePatterns.some((pattern) => matchesSelector(section, pattern));
+};
+var findMatchingSections = (sectionList, selector) => {
+  return sectionList.filter((s) => matchesSelector(s, selector));
+};
+var filterExcludedSections = (sectionList, excludePatterns) => {
+  if (excludePatterns.length === 0) {
+    return sectionList;
+  }
+  return sectionList.filter(
+    (s) => !matchesExclusionPatterns(s, excludePatterns)
+  );
+};
+var getDescendantNumbers = (sectionList, parentNumber) => {
+  const result = /* @__PURE__ */ new Set();
+  const prefix = `${parentNumber}.`;
+  for (const section of sectionList) {
+    if (section.number.startsWith(prefix)) {
+      result.add(section.number);
+    }
+  }
+  return result;
+};
+var extractSectionContent = (document, selector, options = {}) => {
+  const sectionList = buildSectionList(document);
+  let matchedSections = findMatchingSections(sectionList, selector);
+  const excludedNumbers = [];
+  if (options.exclude && options.exclude.length > 0) {
+    const beforeFilter = matchedSections;
+    matchedSections = filterExcludedSections(matchedSections, options.exclude);
+    for (const section of beforeFilter) {
+      if (!matchedSections.includes(section)) {
+        excludedNumbers.push(section.number);
+      }
+    }
+  }
+  if (matchedSections.length === 0) {
+    return { sections: [], matchedNumbers: [], excludedNumbers };
+  }
+  const numbersToInclude = /* @__PURE__ */ new Set();
+  const matchedNumbers = [];
+  for (const matched of matchedSections) {
+    numbersToInclude.add(matched.number);
+    matchedNumbers.push(matched.number);
+    if (!options.shallow) {
+      const descendants = getDescendantNumbers(sectionList, matched.number);
+      for (const desc of descendants) {
+        numbersToInclude.add(desc);
+      }
+    }
+  }
+  const numberToSection = /* @__PURE__ */ new Map();
+  const mapSections = (sections, prefix) => {
+    sections.forEach((section, i) => {
+      const number = prefix ? `${prefix}.${i + 1}` : `${i + 1}`;
+      numberToSection.set(number, section);
+      mapSections(section.children, number);
+    });
+  };
+  mapSections(document.sections, "");
+  const extractedSections = [];
+  for (const number of matchedNumbers) {
+    const section = numberToSection.get(number);
+    if (section) {
+      if (options.shallow) {
+        extractedSections.push({
+          ...section,
+          children: []
+        });
+      } else {
+        extractedSections.push(section);
+      }
+    }
+  }
+  return { sections: extractedSections, matchedNumbers, excludedNumbers };
+};
+var formatExtractedSections = (sections) => {
+  const formatSection = (section, includeChildren) => {
+    const lines = [];
+    const headingPrefix = "#".repeat(section.level);
+    lines.push(`${headingPrefix} ${section.heading}`);
+    lines.push("");
+    const contentLines = section.content.split("\n");
+    const contentWithoutHeading = contentLines.filter((line, i) => i > 0 || !line.startsWith("#")).join("\n").trim();
+    if (contentWithoutHeading) {
+      lines.push(contentWithoutHeading);
+    }
+    if (includeChildren) {
+      for (const child of section.children) {
+        lines.push("");
+        lines.push(formatSection(child, true));
+      }
+    }
+    return lines.join("\n");
+  };
+  return sections.map((s) => formatSection(s, true)).join("\n\n");
+};
+var filterDocumentSections = (document, excludePatterns) => {
+  if (excludePatterns.length === 0) {
+    return { document, excludedCount: 0 };
+  }
+  const sectionList = buildSectionList(document);
+  let excludedCount = 0;
+  const numbersToExclude = /* @__PURE__ */ new Set();
+  for (const section of sectionList) {
+    if (matchesExclusionPatterns(section, excludePatterns)) {
+      const prefix = `${section.number}.`;
+      for (const candidate of sectionList) {
+        if (candidate.number === section.number || candidate.number.startsWith(prefix)) {
+          if (!numbersToExclude.has(candidate.number)) {
+            numbersToExclude.add(candidate.number);
+            excludedCount++;
+          }
+        }
+      }
+    }
+  }
+  if (numbersToExclude.size === 0) {
+    return { document, excludedCount: 0 };
+  }
+  const filterSections = (sections, prefix) => {
+    const result = [];
+    sections.forEach((section, i) => {
+      const number = prefix ? `${prefix}.${i + 1}` : `${i + 1}`;
+      if (!numbersToExclude.has(number)) {
+        result.push({
+          ...section,
+          children: filterSections(section.children, number)
+        });
+      }
+    });
+    return result;
+  };
+  const filteredSections = filterSections(document.sections, "");
+  return {
+    document: {
+      ...document,
+      sections: filteredSections
+    },
+    excludedCount
+  };
+};
+
+// src/summarize/summarizer.ts
+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 = {}) => Effect5.gen(function* () {
+  let document = yield* parseFile(filePath);
+  if (options.exclude && options.exclude.length > 0) {
+    const { document: filteredDoc } = filterDocumentSections(
+      document,
+      options.exclude
+    );
+    document = filteredDoc;
+  }
+  return summarizeDocument(document, options);
+});
+var assembleContext = (rootPath, sourcePaths, options) => Effect5.gen(function* () {
+  const budget = options.budget;
+  const level = options.level ?? "summary";
+  const excludePatterns = options.exclude ?? [];
+  const sources = [];
+  const overflow = [];
+  let totalTokens = 0;
+  const perSourceBudget = Math.floor(budget / sourcePaths.length);
+  for (const sourcePath of sourcePaths) {
+    const resolvedPath = path2.isAbsolute(sourcePath) ? sourcePath : path2.join(rootPath, sourcePath);
+    const summaryResult = yield* summarizeFile(resolvedPath, {
+      level,
+      maxTokens: perSourceBudget,
+      exclude: excludePatterns
+    }).pipe(
+      Effect5.map((s) => s),
+      // Log error for observability before gracefully degrading
+      Effect5.tapError(
+        (error) => Effect5.logError(`Failed to summarize ${sourcePath}`, error)
+      ),
+      // Note: catchAll intentional for batch processing - individual file
+      // failures add to overflow instead of stopping assembly
+      Effect5.catchAll(() => Effect5.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: path2.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,
+          exclude: excludePatterns
+        }).pipe(
+          Effect5.map((s) => s),
+          // Log error for observability before gracefully degrading
+          Effect5.tapError(
+            (error) => Effect5.logError(
+              `Failed to create brief summary for ${sourcePath}`,
+              error
+            )
+          ),
+          Effect5.catchAll(
+            () => Effect5.succeed(null)
+          )
+        );
+        if (briefSummary) {
+          const briefContent = formatSummary(briefSummary);
+          const briefTokens = countTokensApprox(briefContent);
+          sources.push({
+            path: path2.relative(rootPath, resolvedPath),
+            title: briefSummary.title,
+            tokens: briefTokens,
+            content: briefContent
+          });
+          totalTokens += briefTokens;
+        } else {
+          overflow.push(path2.relative(rootPath, resolvedPath));
+        }
+      } else {
+        overflow.push(path2.relative(rootPath, resolvedPath));
+      }
+    }
+  }
+  return {
+    sources,
+    totalTokens,
+    budget,
+    overflow
+  };
+});
+
+// src/embeddings/semantic-search.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import { Effect as Effect11 } from "effect";
+
+// src/embeddings/hyde.ts
+import { Effect as Effect6, Redacted } from "effect";
+import OpenAI from "openai";
+var DEFAULT_MODEL = "gpt-4o-mini";
+var DEFAULT_MAX_TOKENS = 256;
+var DEFAULT_TEMPERATURE = 0.3;
+var DEFAULT_SYSTEM_PROMPT = `You are a technical documentation assistant. Given a user's question, write a short, factual passage that would appear in documentation answering this question.
+
+Guidelines:
+- Write 2-4 concise paragraphs
+- Use technical but accessible language
+- Include specific details, code examples, or configuration options where relevant
+- Focus on directly answering the question
+- Do not include greetings, preambles, or meta-commentary
+- Write as if this is an excerpt from existing documentation`;
+var LLM_PRICING = {
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 }
+};
+var generateHypotheticalDocument = (query, options = {}) => Effect6.gen(function* () {
+  const rawApiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+  if (!rawApiKey) {
+    return yield* Effect6.fail(
+      new ApiKeyMissingError({
+        provider: "OpenAI",
+        envVar: "OPENAI_API_KEY"
+      })
+    );
+  }
+  const redactedApiKey = Redacted.isRedacted(rawApiKey) ? rawApiKey : Redacted.make(rawApiKey);
+  const client = new OpenAI({
+    apiKey: Redacted.value(redactedApiKey),
+    // Only expose when creating client
+    baseURL: options.baseURL
+  });
+  const model = options.model ?? DEFAULT_MODEL;
+  const maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+  const temperature = options.temperature ?? DEFAULT_TEMPERATURE;
+  const systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  const response = yield* Effect6.tryPromise({
+    try: async () => client.chat.completions.create({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: query }
+      ],
+      max_tokens: maxTokens,
+      temperature
+    }),
+    catch: (error) => new EmbeddingError({
+      reason: classifyLLMError(error),
+      message: error instanceof Error ? error.message : String(error),
+      provider: "openai",
+      cause: error
+    })
+  });
+  const content = response.choices[0]?.message?.content ?? "";
+  const inputTokens = response.usage?.prompt_tokens ?? 0;
+  const outputTokens = response.usage?.completion_tokens ?? 0;
+  const totalTokens = inputTokens + outputTokens;
+  const pricing = LLM_PRICING[model] ?? LLM_PRICING["gpt-4o-mini"];
+  const cost = inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+  return {
+    hypotheticalDocument: content,
+    originalQuery: query,
+    model,
+    tokensUsed: totalTokens,
+    cost
+  };
+});
+var classifyLLMError = (error) => {
+  if (error instanceof OpenAI.RateLimitError) {
+    return "RateLimit";
+  }
+  if (error instanceof OpenAI.BadRequestError) {
+    const msg2 = (error.message || "").toLowerCase();
+    if (msg2.includes("model")) return "ModelError";
+  }
+  if (error instanceof OpenAI.APIConnectionError) {
+    return "Network";
+  }
+  if (!(error instanceof Error)) return "Unknown";
+  const msg = error.message.toLowerCase();
+  if (msg.includes("429") || msg.includes("rate limit")) return "RateLimit";
+  if (msg.includes("quota") || msg.includes("billing")) return "QuotaExceeded";
+  if (msg.includes("econnrefused") || msg.includes("network")) return "Network";
+  if (msg.includes("model") && msg.includes("not found")) return "ModelError";
+  return "Unknown";
+};
+
+// src/embeddings/openai-provider.ts
+import { Effect as Effect7, Redacted as Redacted2 } from "effect";
+import OpenAI2 from "openai";
+
+// src/embeddings/provider-constants.ts
+var MODEL_DIMENSIONS = {
+  // OpenAI models (support MRL dimension reduction)
+  "text-embedding-3-small": 1536,
+  // Native: 1536, supports reduction
+  "text-embedding-3-large": 3072,
+  // Native: 3072, supports reduction
+  "text-embedding-ada-002": 1536,
+  // Native: 1536, does NOT support reduction
+  // Ollama models (fixed native dimensions)
+  "nomic-embed-text": 768,
+  "mxbai-embed-large": 1024,
+  "bge-m3": 1024,
+  "all-minilm": 384,
+  "snowflake-arctic-embed": 1024,
+  // Voyage AI models (fixed native dimensions)
+  "voyage-3.5-lite": 1024,
+  // Best value: $0.02/1M tokens
+  "voyage-3": 1024,
+  // Higher quality: $0.06/1M tokens
+  "voyage-code-3": 1024,
+  // Code-optimized: $0.18/1M tokens
+  "voyage-2": 1024,
+  "voyage-large-2": 1536,
+  "voyage-code-2": 1536
+};
+var MATRYOSHKA_MODELS = /* @__PURE__ */ new Set([
+  "text-embedding-3-small",
+  "text-embedding-3-large"
+]);
+var supportsMatryoshka = (model) => MATRYOSHKA_MODELS.has(model);
+var getRecommendedDimensions = (model) => {
+  if (supportsMatryoshka(model)) {
+    return 512;
+  }
+  return MODEL_DIMENSIONS[model];
+};
+var validateModelDimensions = (model, dimensions) => {
+  const nativeDims = MODEL_DIMENSIONS[model];
+  if (nativeDims === void 0) {
+    return { isValid: true };
+  }
+  if (dimensions > nativeDims) {
+    return {
+      isValid: false,
+      warning: `Model '${model}' has ${nativeDims} native dimensions, cannot use ${dimensions}`
+    };
+  }
+  if (!supportsMatryoshka(model) && dimensions !== nativeDims) {
+    return {
+      isValid: false,
+      warning: `Model '${model}' does not support dimension reduction, must use ${nativeDims}`
+    };
+  }
+  return { isValid: true };
+};
+var PROVIDER_BASE_URLS = {
+  openai: void 0,
+  // Use OpenAI SDK default
+  ollama: "http://localhost:11434/v1",
+  "lm-studio": "http://localhost:1234/v1",
+  openrouter: "https://openrouter.ai/api/v1",
+  voyage: "https://api.voyageai.com/v1"
+  // Native API, handled by VoyageProvider
+};
+var extractPortFromUrl = (url) => {
+  const match = url.match(/:(\d+)\//);
+  if (!match?.[1]) return void 0;
+  return parseInt(match[1], 10);
+};
+var PROVIDER_PORTS = (() => {
+  const ports = {};
+  for (const [provider, url] of Object.entries(PROVIDER_BASE_URLS)) {
+    if (url) {
+      const port = extractPortFromUrl(url);
+      if (port) ports[provider] = port;
+    }
+  }
+  return ports;
+})();
+var inferProviderFromUrl = (baseURL) => {
+  if (!baseURL) return "openai";
+  for (const [provider, providerUrl] of Object.entries(PROVIDER_BASE_URLS)) {
+    if (providerUrl && baseURL.includes(providerUrl.replace("/v1", ""))) {
+      return provider;
+    }
+  }
+  if (baseURL.includes("openrouter")) return "openrouter";
+  return "openai";
+};
+
+// src/embeddings/openai-provider.ts
+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;
+  /** Provider name for error context */
+  providerName;
+  /** Model name */
+  model;
+  /** Base URL for API requests */
+  baseURL;
+  client;
+  batchSize;
+  constructor(apiKey, options = {}) {
+    this.baseURL = options.baseURL;
+    this.client = new OpenAI2({
+      apiKey: Redacted2.value(apiKey),
+      // Only expose API key when creating client
+      baseURL: options.baseURL
+      // If undefined, SDK uses default https://api.openai.com/v1
+    });
+    this.model = options.model ?? "text-embedding-3-small";
+    this.batchSize = options.batchSize ?? 100;
+    this.providerName = options.providerName ?? this.inferProviderName(options.baseURL);
+    this.name = `${this.providerName}:${this.model}`;
+    const recommendedDims = getRecommendedDimensions(this.model);
+    this.dimensions = options.dimensions ?? recommendedDims ?? 512;
+  }
+  /**
+   * Infer the provider name from the baseURL.
+   * Delegates to centralized inferProviderFromUrl for single source of truth.
+   */
+  inferProviderName(baseURL) {
+    return inferProviderFromUrl(baseURL);
+  }
+  /**
+   * Create an OpenAI provider instance.
+   * Returns an Effect that fails with ApiKeyMissingError if no API key is available.
+   *
+   * API keys are handled securely using Effect's Redacted type to prevent
+   * accidental logging of sensitive values.
+   */
+  static create(options = {}) {
+    const isOpenRouter = options.baseURL?.includes("openrouter") || options.providerName === "openrouter";
+    const resolveApiKey = () => {
+      if (options.apiKey !== void 0) {
+        return options.apiKey;
+      }
+      return (isOpenRouter ? process.env.OPENROUTER_API_KEY : void 0) ?? process.env.OPENAI_API_KEY;
+    };
+    const rawApiKey = resolveApiKey();
+    if (!rawApiKey) {
+      return Effect7.fail(
+        new ApiKeyMissingError({
+          provider: isOpenRouter ? "OpenRouter" : "OpenAI",
+          envVar: isOpenRouter ? "OPENROUTER_API_KEY" : "OPENAI_API_KEY"
+        })
+      );
+    }
+    const redactedApiKey = Redacted2.isRedacted(rawApiKey) ? rawApiKey : Redacted2.make(rawApiKey);
+    const apiKeyValue = Redacted2.value(redactedApiKey);
+    const shouldWarnOpenRouter = isOpenRouter && apiKeyValue.startsWith("sk-") && !apiKeyValue.startsWith("sk-or-");
+    const model = options.model ?? "text-embedding-3-small";
+    const dimensionValidation = options.dimensions ? validateModelDimensions(model, options.dimensions) : { isValid: true };
+    return Effect7.succeed(new _OpenAIProvider(redactedApiKey, options)).pipe(
+      shouldWarnOpenRouter ? Effect7.tap(
+        () => Effect7.logWarning(
+          '\u26A0\uFE0F  Using OpenAI key format with OpenRouter. Consider setting OPENROUTER_API_KEY with a key starting with "sk-or-"'
+        )
+      ) : (self) => self,
+      // Warn about invalid dimension configuration
+      dimensionValidation.warning ? Effect7.tap(
+        () => Effect7.logWarning(`\u26A0\uFE0F  ${dimensionValidation.warning}`)
+      ) : (self) => self
+    );
+  }
+  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 embedParams = {
+          model: this.model,
+          input: batch
+        };
+        if (supportsMatryoshka(this.model)) {
+          embedParams.dimensions = this.dimensions;
+        }
+        const response = await this.client.embeddings.create(embedParams);
+        for (const item of response.data) {
+          allEmbeddings.push(item.embedding);
+        }
+        totalTokens += response.usage?.total_tokens ?? 0;
+      }
+    } catch (error) {
+      if (error instanceof OpenAI2.AuthenticationError) {
+        throw new ApiKeyInvalidError({
+          provider: this.providerName,
+          details: error.message
+        });
+      }
+      throw new EmbeddingError({
+        reason: this.classifyError(error),
+        message: error instanceof Error ? error.message : String(error),
+        provider: this.providerName,
+        cause: error
+      });
+    }
+    const pricePerMillion = this.providerName === "openai" || this.providerName === "openrouter" ? PRICING_DATA.prices[this.model] ?? 0.02 : 0;
+    const cost = totalTokens / 1e6 * pricePerMillion;
+    return {
+      embeddings: allEmbeddings,
+      tokensUsed: totalTokens,
+      cost
+    };
+  }
+  /**
+   * Classify an error into a known category for better error handling.
+   * Uses OpenAI SDK error types where available, falls back to string matching
+   * for non-OpenAI providers (Ollama, LM Studio, OpenRouter).
+   */
+  classifyError(error) {
+    if (error instanceof OpenAI2.RateLimitError) {
+      return "RateLimit";
+    }
+    if (error instanceof OpenAI2.BadRequestError) {
+      const msg2 = error.message.toLowerCase();
+      if (msg2.includes("model")) return "ModelError";
+    }
+    if (error instanceof OpenAI2.APIConnectionError) {
+      return "Network";
+    }
+    if (!(error instanceof Error)) return "Unknown";
+    const msg = error.message.toLowerCase();
+    if (msg.includes("429") || msg.includes("rate limit") || msg.includes("too many requests")) {
+      return "RateLimit";
+    }
+    if (msg.includes("quota") || msg.includes("insufficient") || msg.includes("billing")) {
+      return "QuotaExceeded";
+    }
+    if (msg.includes("econnrefused") || msg.includes("timeout") || msg.includes("network") || msg.includes("enotfound") || msg.includes("connection")) {
+      return "Network";
+    }
+    if (msg.includes("model") && (msg.includes("not found") || msg.includes("not exist") || msg.includes("invalid"))) {
+      return "ModelError";
+    }
+    return "Unknown";
+  }
+};
+var createOpenAIProvider = (options) => OpenAIProvider.create(options);
+var wrapEmbedding = (embedPromise, providerName = "openai") => Effect7.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: providerName,
+      cause: e
+    });
+  }
+});
+
+// src/embeddings/provider-factory.ts
+import { Effect as Effect9, Option, Redacted as Redacted4 } from "effect";
+
+// src/embeddings/voyage-provider.ts
+import { Effect as Effect8, Redacted as Redacted3 } from "effect";
+var VOYAGE_API_BASE = "https://api.voyageai.com/v1";
+var VOYAGE_MODELS = {
+  "voyage-3.5-lite": { dimensions: 1024, pricePerMillion: 0.02 },
+  "voyage-3": { dimensions: 1024, pricePerMillion: 0.06 },
+  "voyage-code-3": { dimensions: 1024, pricePerMillion: 0.18 },
+  // Legacy models
+  "voyage-2": { dimensions: 1024, pricePerMillion: 0.1 },
+  "voyage-large-2": { dimensions: 1536, pricePerMillion: 0.12 },
+  "voyage-code-2": { dimensions: 1536, pricePerMillion: 0.12 }
+};
+var DEFAULT_VOYAGE_MODEL = "voyage-3.5-lite";
+var VoyageProvider = class _VoyageProvider {
+  name;
+  dimensions;
+  model;
+  baseURL = VOYAGE_API_BASE;
+  providerName = "voyage";
+  apiKey;
+  batchSize;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.model = options.model ?? DEFAULT_VOYAGE_MODEL;
+    this.batchSize = options.batchSize ?? 128;
+    const modelSpec = VOYAGE_MODELS[this.model];
+    this.dimensions = modelSpec?.dimensions ?? 1024;
+    this.name = `voyage:${this.model}`;
+  }
+  /**
+   * Create a Voyage provider instance.
+   * Returns an Effect that fails with ApiKeyMissingError if no API key is available.
+   *
+   * API keys are handled securely using Effect's Redacted type to prevent
+   * accidental logging of sensitive values.
+   */
+  static create(options = {}) {
+    const rawApiKey = options.apiKey ?? process.env.VOYAGE_API_KEY;
+    if (!rawApiKey) {
+      return Effect8.fail(
+        new ApiKeyMissingError({
+          provider: "Voyage AI",
+          envVar: "VOYAGE_API_KEY"
+        })
+      );
+    }
+    const redactedApiKey = Redacted3.isRedacted(rawApiKey) ? rawApiKey : Redacted3.make(rawApiKey);
+    return Effect8.succeed(new _VoyageProvider(redactedApiKey, 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 fetch(`${VOYAGE_API_BASE}/embeddings`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${Redacted3.value(this.apiKey)}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: this.model,
+            input: batch,
+            input_type: "document"
+            // 'document' for indexing, 'query' for searching
+          })
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (response.status === 401) {
+            throw new ApiKeyInvalidError({
+              provider: "Voyage AI",
+              details: errorText
+            });
+          }
+          throw new EmbeddingError({
+            reason: this.classifyHttpError(response.status, errorText),
+            message: `Voyage API error: ${response.status} - ${errorText}`,
+            provider: "voyage"
+          });
+        }
+        const data = await response.json();
+        for (const item of data.data) {
+          allEmbeddings.push(item.embedding);
+        }
+        totalTokens += data.usage?.total_tokens ?? 0;
+      }
+    } catch (error) {
+      if (error instanceof ApiKeyInvalidError || error instanceof EmbeddingError) {
+        throw error;
+      }
+      throw new EmbeddingError({
+        reason: this.classifyError(error),
+        message: error instanceof Error ? error.message : String(error),
+        provider: "voyage",
+        cause: error
+      });
+    }
+    const pricePerMillion = VOYAGE_MODELS[this.model]?.pricePerMillion ?? 0.02;
+    const cost = totalTokens / 1e6 * pricePerMillion;
+    return {
+      embeddings: allEmbeddings,
+      tokensUsed: totalTokens,
+      cost
+    };
+  }
+  classifyHttpError(status, _message) {
+    if (status === 429) return "RateLimit";
+    if (status === 402) return "QuotaExceeded";
+    if (status === 400) return "ModelError";
+    return "Unknown";
+  }
+  classifyError(error) {
+    if (!(error instanceof Error)) return "Unknown";
+    const msg = error.message.toLowerCase();
+    if (msg.includes("rate limit") || msg.includes("429")) return "RateLimit";
+    if (msg.includes("quota") || msg.includes("billing")) return "QuotaExceeded";
+    if (msg.includes("econnrefused") || msg.includes("timeout") || msg.includes("network"))
+      return "Network";
+    if (msg.includes("model") && msg.includes("not found")) return "ModelError";
+    return "Unknown";
+  }
+};
+var createVoyageProvider = (options) => VoyageProvider.create(options);
+
+// src/embeddings/provider-factory.ts
+var getProviderBaseURL = (provider, configBaseURL) => {
+  if (Option.isSome(configBaseURL)) {
+    return configBaseURL.value;
+  }
+  return PROVIDER_BASE_URLS[provider];
+};
+var normalizeBaseURL = (baseURL) => {
+  if (baseURL === void 0) {
+    return Option.none();
+  }
+  if (typeof baseURL === "string") {
+    return Option.some(baseURL);
+  }
+  return baseURL;
+};
+var normalizeApiKey = (apiKey) => {
+  if (apiKey === void 0) {
+    return void 0;
+  }
+  if (Redacted4.isRedacted(apiKey)) {
+    return apiKey;
+  }
+  if (typeof apiKey === "string") {
+    return apiKey;
+  }
+  return Option.isSome(apiKey) ? apiKey.value : void 0;
+};
+var createEmbeddingProviderDirect = (config) => Effect9.gen(function* () {
+  const provider = config.provider;
+  const baseURL = getProviderBaseURL(
+    provider,
+    normalizeBaseURL(config.baseURL)
+  );
+  if (provider === "voyage") {
+    return yield* createVoyageProvider({
+      model: config.model,
+      batchSize: config.batchSize,
+      apiKey: normalizeApiKey(config.apiKey)
+    });
+  }
+  return yield* createOpenAIProvider({
+    model: config.model,
+    dimensions: config.dimensions,
+    batchSize: config.batchSize,
+    baseURL,
+    apiKey: normalizeApiKey(config.apiKey)
+  });
+});
+
+// src/embeddings/types.ts
+var hasProviderMetadata = (provider) => {
+  return "model" in provider && typeof provider.model === "string";
+};
+var QUALITY_EF_SEARCH = {
+  fast: 64,
+  balanced: 100,
+  thorough: 256
+};
+var HEADING_BOOST_FACTOR = 0.05;
+var FILE_IMPORTANCE_BOOST = 0.03;
+var IMPORTANT_FILE_PATTERNS = [
+  /^readme\.md$/i,
+  // Root README
+  /\/readme\.md$/i,
+  // Nested README
+  /^index\.md$/i,
+  // Index files
+  /\/index\.md$/i,
+  /^getting-?started/i,
+  // Getting started guides
+  /\/getting-?started/i,
+  /^introduction/i,
+  // Introductions
+  /\/introduction/i,
+  /^overview/i,
+  // Overviews
+  /\/overview/i,
+  /^quickstart/i,
+  // Quickstart guides
+  /\/quickstart/i,
+  /^changelog\.md$/i,
+  // Changelogs (useful for "what changed" queries)
+  /\/changelog\.md$/i
+];
+var calculateFileImportanceBoost = (documentPath) => {
+  const isImportant = IMPORTANT_FILE_PATTERNS.some(
+    (pattern) => pattern.test(documentPath)
+  );
+  return isImportant ? FILE_IMPORTANCE_BOOST : 0;
+};
+var calculateHeadingBoost = (heading, query) => {
+  const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  if (queryTerms.length === 0) return 0;
+  const headingLower = heading.toLowerCase();
+  const matchCount = queryTerms.filter(
+    (term) => headingLower.includes(term)
+  ).length;
+  return matchCount * HEADING_BOOST_FACTOR;
+};
+var preprocessQuery = (query) => {
+  return query.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
+};
+
+// src/embeddings/vector-store.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+import { Effect as Effect10 } from "effect";
+import HierarchicalNSW from "hnswlib-node";
+var VECTOR_INDEX_FILE = "vectors.bin";
+var VECTOR_META_FILE = "vectors.meta.json";
+var INDEX_VERSION = 1;
+var HnswVectorStore = class {
+  rootPath;
+  dimensions;
+  index = null;
+  entries = /* @__PURE__ */ new Map();
+  idToIndex = /* @__PURE__ */ new Map();
+  nextIndex = 0;
+  provider = "unknown";
+  providerModel = void 0;
+  providerBaseURL = void 0;
+  totalCost = 0;
+  totalTokens = 0;
+  // HNSW build parameters
+  hnswM;
+  hnswEfConstruction;
+  constructor(rootPath, dimensions, hnswOptions) {
+    this.rootPath = path3.resolve(rootPath);
+    this.dimensions = dimensions;
+    this.hnswM = hnswOptions?.m ?? 16;
+    this.hnswEfConstruction = hnswOptions?.efConstruction ?? 200;
+  }
+  getIndexDir() {
+    return path3.join(this.rootPath, INDEX_DIR);
+  }
+  getVectorPath() {
+    return path3.join(this.getIndexDir(), VECTOR_INDEX_FILE);
+  }
+  getMetaPath() {
+    return path3.join(this.getIndexDir(), VECTOR_META_FILE);
+  }
+  ensureIndex() {
+    if (!this.index) {
+      this.index = new HierarchicalNSW.HierarchicalNSW(
+        "cosine",
+        this.dimensions
+      );
+      this.index.initIndex(1e4, this.hnswM, this.hnswEfConstruction, 100);
+    }
+    return this.index;
+  }
+  add(entries) {
+    return Effect10.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, options) {
+    return Effect10.try({
+      try: () => {
+        if (!this.index || this.entries.size === 0) {
+          return [];
+        }
+        if (options?.efSearch !== void 0) {
+          this.index.setEf(options.efSearch);
+        }
+        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
+      })
+    });
+  }
+  searchWithStats(vector, limit, threshold = 0, options) {
+    return Effect10.try({
+      try: () => {
+        if (!this.index || this.entries.size === 0) {
+          return {
+            results: [],
+            belowThresholdCount: 0,
+            belowThresholdHighest: null
+          };
+        }
+        if (options?.efSearch !== void 0) {
+          this.index.setEf(options.efSearch);
+        }
+        const result = this.index.searchKnn(
+          vector,
+          Math.min(limit, this.entries.size)
+        );
+        const results = [];
+        let belowThresholdCount = 0;
+        let belowThresholdHighest = null;
+        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;
+          const entry = this.entries.get(idx);
+          if (!entry) continue;
+          if (similarity < threshold) {
+            belowThresholdCount++;
+            if (belowThresholdHighest === null || similarity > belowThresholdHighest) {
+              belowThresholdHighest = similarity;
+            }
+            continue;
+          }
+          results.push({
+            id: entry.id,
+            sectionId: entry.sectionId,
+            documentPath: entry.documentPath,
+            heading: entry.heading,
+            similarity
+          });
+        }
+        return {
+          results,
+          belowThresholdCount,
+          belowThresholdHighest
+        };
+      },
+      catch: (e) => new VectorStoreError({
+        operation: "search",
+        message: e instanceof Error ? e.message : String(e),
+        cause: e
+      })
+    });
+  }
+  save() {
+    return Effect10.gen(
+      function* () {
+        if (!this.index) {
+          return;
+        }
+        const indexDir = this.getIndexDir();
+        yield* Effect10.tryPromise({
+          try: () => fs3.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* Effect10.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,
+          providerModel: this.providerModel,
+          providerBaseURL: this.providerBaseURL,
+          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(),
+          // Store HNSW build parameters for validation on load
+          hnswParams: {
+            m: this.hnswM,
+            efConstruction: this.hnswEfConstruction
+          }
+        };
+        yield* Effect10.tryPromise({
+          try: () => fs3.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 Effect10.gen(
+      function* () {
+        const vectorPath = this.getVectorPath();
+        const metaPath = this.getMetaPath();
+        const filesExist = yield* Effect10.tryPromise({
+          try: async () => {
+            await fs3.access(vectorPath);
+            await fs3.access(metaPath);
+            return true;
+          },
+          catch: () => new VectorStoreError({
+            operation: "load",
+            message: "Files not found"
+          })
+        }).pipe(
+          Effect10.catchTag("VectorStoreError", () => Effect10.succeed(false))
+        );
+        if (!filesExist) {
+          return { loaded: false };
+        }
+        const metaContent = yield* Effect10.tryPromise({
+          try: () => fs3.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 loadedMeta = yield* Effect10.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
+          })
+        });
+        const meta = {
+          ...loadedMeta,
+          provider: loadedMeta.provider || "openai"
+        };
+        if (meta.dimensions !== this.dimensions) {
+          return yield* Effect10.fail(
+            new DimensionMismatchError({
+              corpusDimensions: meta.dimensions,
+              providerDimensions: this.dimensions,
+              corpusProvider: meta.providerModel ? `${meta.provider}:${meta.providerModel}` : meta.provider,
+              path: this.rootPath
+            })
+          );
+        }
+        this.index = new HierarchicalNSW.HierarchicalNSW(
+          "cosine",
+          this.dimensions
+        );
+        yield* Effect10.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.providerModel = meta.providerModel;
+        this.providerBaseURL = meta.providerBaseURL;
+        this.totalCost = meta.totalCost;
+        this.totalTokens = meta.totalTokens;
+        let hnswMismatch;
+        if (meta.hnswParams) {
+          const indexM = meta.hnswParams.m;
+          const indexEf = meta.hnswParams.efConstruction;
+          if (indexM !== this.hnswM || indexEf !== this.hnswEfConstruction) {
+            hnswMismatch = {
+              configParams: {
+                m: this.hnswM,
+                efConstruction: this.hnswEfConstruction
+              },
+              indexParams: { m: indexM, efConstruction: indexEf }
+            };
+          }
+        }
+        return { loaded: true, hnswMismatch };
+      }.bind(this)
+    );
+  }
+  getStats() {
+    return {
+      count: this.entries.size,
+      dimensions: this.dimensions,
+      provider: this.provider,
+      providerModel: this.providerModel,
+      totalCost: this.totalCost,
+      totalTokens: this.totalTokens
+    };
+  }
+  setProvider(name, model, baseURL) {
+    this.provider = name;
+    this.providerModel = model;
+    this.providerBaseURL = baseURL;
+  }
+  addCost(cost, tokens) {
+    this.totalCost += cost;
+    this.totalTokens += tokens;
+  }
+};
+var createVectorStore = (rootPath, dimensions, hnswOptions) => new HnswVectorStore(rootPath, dimensions, hnswOptions);
+
+// src/embeddings/semantic-search.ts
+var checkHnswMismatch = (mismatch) => {
+  if (!mismatch) {
+    return Effect11.void;
+  }
+  const { configParams, indexParams } = mismatch;
+  return Effect11.logWarning(
+    `HNSW parameter mismatch: Index was built with M=${indexParams.m}, efConstruction=${indexParams.efConstruction}, but config specifies M=${configParams.m}, efConstruction=${configParams.efConstruction}. HNSW parameters only affect index construction. Run 'mdcontext index --embed --force' to rebuild with new parameters.`
+  );
+};
+var checkProviderMismatch = (stats, currentProvider, currentProviderModel) => {
+  if (stats.providerModel && stats.providerModel !== currentProviderModel) {
+    return Effect11.logWarning(
+      `Provider mismatch: Index was created with ${stats.provider}/${stats.providerModel}, but querying with ${currentProvider}/${currentProviderModel}. Results may be inconsistent. Consider re-indexing.`
+    );
+  }
+  if (!stats.providerModel) {
+    const indexProviderParts = stats.provider.split(":");
+    if (indexProviderParts.length === 2 && indexProviderParts[1] !== currentProviderModel) {
+      return Effect11.logWarning(
+        `Provider mismatch: Index was created with ${indexProviderParts[0]}/${indexProviderParts[1]}, but querying with ${currentProvider}/${currentProviderModel}. Results may be inconsistent. Consider re-indexing.`
+      );
+    }
+  }
+  return Effect11.void;
+};
+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 = {}) => Effect11.gen(function* () {
+  const resolvedRoot = path4.resolve(rootPath);
+  const storage = createStorage(resolvedRoot);
+  const docIndex = yield* loadDocumentIndex(storage);
+  const sectionIndex = yield* loadSectionIndex(storage);
+  if (!docIndex || !sectionIndex) {
+    return yield* Effect11.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 = path4.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 = {}) => Effect11.gen(function* () {
+  const startTime = Date.now();
+  const resolvedRoot = path4.resolve(rootPath);
+  const storage = createStorage(resolvedRoot);
+  const docIndex = yield* loadDocumentIndex(storage);
+  const sectionIndex = yield* loadSectionIndex(storage);
+  if (!docIndex || !sectionIndex) {
+    return yield* Effect11.fail(new IndexNotFoundError({ path: resolvedRoot }));
+  }
+  const providerConfig = options.providerConfig ?? { provider: "openai" };
+  const provider = options.provider ?? (yield* createEmbeddingProviderDirect(providerConfig));
+  const dimensions = provider.dimensions;
+  const vectorStore = createVectorStore(
+    resolvedRoot,
+    dimensions,
+    options.hnswOptions
+  );
+  if (hasProviderMetadata(provider)) {
+    vectorStore.setProvider(provider.name, provider.model, provider.baseURL);
+  } else {
+    vectorStore.setProvider(provider.name, void 0, void 0);
+  }
+  if (!options.force) {
+    const loadResult = yield* vectorStore.load();
+    if (loadResult.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 = path4.join(resolvedRoot, docPath);
+    const fileContentResult = yield* Effect11.promise(
+      () => fs4.readFile(filePath, "utf-8")
+    ).pipe(
+      Effect11.map((content) => ({ ok: true, content })),
+      Effect11.catchAll(
+        () => Effect11.succeed({ ok: false, content: "" })
+      )
+    );
+    if (!fileContentResult.ok) {
+      yield* Effect11.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),
+    providerConfig.provider ?? "openai"
+  );
+  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 = {}) => Effect11.gen(function* () {
+  const resolvedRoot = path4.resolve(rootPath);
+  const provider = yield* createEmbeddingProviderDirect(
+    options.providerConfig ?? { provider: "openai" }
+  );
+  const dimensions = provider.dimensions;
+  const vectorStore = createVectorStore(resolvedRoot, dimensions);
+  const loadResult = yield* vectorStore.load();
+  if (!loadResult.loaded) {
+    return yield* Effect11.fail(
+      new EmbeddingsNotFoundError({ path: resolvedRoot })
+    );
+  }
+  const stats = vectorStore.getStats();
+  const currentProviderModel = options.providerConfig?.model ?? "text-embedding-3-small";
+  const currentProvider = options.providerConfig?.provider ?? "openai";
+  yield* checkProviderMismatch(stats, currentProvider, currentProviderModel);
+  yield* checkHnswMismatch(loadResult.hnswMismatch);
+  let textToEmbed;
+  let hydeResult;
+  if (options.hyde) {
+    hydeResult = yield* generateHypotheticalDocument(query, {
+      model: options.hydeOptions?.model,
+      maxTokens: options.hydeOptions?.maxTokens,
+      temperature: options.hydeOptions?.temperature
+    });
+    textToEmbed = hydeResult.hypotheticalDocument;
+    yield* Effect11.logDebug(
+      `HyDE generated ${hydeResult.tokensUsed} tokens ($${hydeResult.cost.toFixed(6)})`
+    );
+  } else {
+    textToEmbed = options.skipPreprocessing ? query : preprocessQuery(query);
+  }
+  const queryResult = yield* wrapEmbedding(
+    provider.embed([textToEmbed]),
+    currentProvider
+  );
+  const queryVector = queryResult.embeddings[0];
+  if (!queryVector) {
+    return yield* Effect11.fail(
+      new EmbeddingError({
+        reason: "Unknown",
+        message: "Failed to generate query embedding",
+        provider: currentProvider
+      })
+    );
+  }
+  const limit = options.limit ?? 10;
+  const threshold = options.threshold ?? 0;
+  const efSearch = options.quality ? QUALITY_EF_SEARCH[options.quality] : void 0;
+  const searchResults = yield* vectorStore.search(
+    queryVector,
+    limit * 2,
+    threshold,
+    { efSearch }
+  );
+  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 applyBoost = options.headingBoost !== false;
+  const boostedResults = applyBoost ? filteredResults.map((r) => ({
+    ...r,
+    similarity: Math.min(
+      1,
+      r.similarity + calculateHeadingBoost(r.heading, query) + calculateFileImportanceBoost(r.documentPath)
+    )
+  })) : filteredResults;
+  const results = boostedResults.sort((a, b) => b.similarity - a.similarity).slice(0, limit).map((r) => ({
+    sectionId: r.sectionId,
+    documentPath: r.documentPath,
+    heading: r.heading,
+    similarity: r.similarity
+  }));
+  return results;
+});
+var semanticSearchWithStats = (rootPath, query, options = {}) => Effect11.gen(function* () {
+  const resolvedRoot = path4.resolve(rootPath);
+  const provider = yield* createEmbeddingProviderDirect(
+    options.providerConfig ?? { provider: "openai" }
+  );
+  const dimensions = provider.dimensions;
+  const vectorStore = createVectorStore(resolvedRoot, dimensions);
+  const loadResult = yield* vectorStore.load();
+  if (!loadResult.loaded) {
+    return yield* Effect11.fail(
+      new EmbeddingsNotFoundError({ path: resolvedRoot })
+    );
+  }
+  const stats = vectorStore.getStats();
+  const currentProviderModel = options.providerConfig?.model ?? "text-embedding-3-small";
+  const currentProvider = options.providerConfig?.provider ?? "openai";
+  yield* checkProviderMismatch(stats, currentProvider, currentProviderModel);
+  yield* checkHnswMismatch(loadResult.hnswMismatch);
+  let textToEmbed;
+  let hydeResult;
+  if (options.hyde) {
+    hydeResult = yield* generateHypotheticalDocument(query, {
+      model: options.hydeOptions?.model,
+      maxTokens: options.hydeOptions?.maxTokens,
+      temperature: options.hydeOptions?.temperature
+    });
+    textToEmbed = hydeResult.hypotheticalDocument;
+    yield* Effect11.logDebug(
+      `HyDE generated ${hydeResult.tokensUsed} tokens ($${hydeResult.cost.toFixed(6)})`
+    );
+  } else {
+    textToEmbed = options.skipPreprocessing ? query : preprocessQuery(query);
+  }
+  const queryResult = yield* wrapEmbedding(
+    provider.embed([textToEmbed]),
+    currentProvider
+  );
+  const queryVector = queryResult.embeddings[0];
+  if (!queryVector) {
+    return yield* Effect11.fail(
+      new EmbeddingError({
+        reason: "Unknown",
+        message: "Failed to generate query embedding",
+        provider: currentProvider
+      })
+    );
+  }
+  const limit = options.limit ?? 10;
+  const threshold = options.threshold ?? 0;
+  const efSearch = options.quality ? QUALITY_EF_SEARCH[options.quality] : void 0;
+  const searchResultWithStats = yield* vectorStore.searchWithStats(
+    queryVector,
+    limit * 2,
+    threshold,
+    { efSearch }
+  );
+  let filteredResults = searchResultWithStats.results;
+  if (options.pathPattern) {
+    const pattern = options.pathPattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${pattern}$`, "i");
+    filteredResults = searchResultWithStats.results.filter(
+      (r) => regex.test(r.documentPath)
+    );
+  }
+  const applyBoost = options.headingBoost !== false;
+  const boostedResults = applyBoost ? filteredResults.map((r) => ({
+    ...r,
+    similarity: Math.min(
+      1,
+      r.similarity + calculateHeadingBoost(r.heading, query) + calculateFileImportanceBoost(r.documentPath)
+    )
+  })) : filteredResults;
+  const sortedResults = boostedResults.sort(
+    (a, b) => b.similarity - a.similarity
+  );
+  const totalAvailable = sortedResults.length;
+  const results = sortedResults.slice(0, limit).map((r) => ({
+    sectionId: r.sectionId,
+    documentPath: r.documentPath,
+    heading: r.heading,
+    similarity: r.similarity
+  }));
+  return {
+    results,
+    belowThresholdCount: searchResultWithStats.belowThresholdCount,
+    belowThresholdHighest: searchResultWithStats.belowThresholdHighest ?? void 0,
+    totalAvailable
+  };
+});
+var getEmbeddingStats = (rootPath) => Effect11.gen(function* () {
+  const resolvedRoot = path4.resolve(rootPath);
+  const metaPath = path4.join(resolvedRoot, INDEX_DIR, "vectors.meta.json");
+  const metaContent = yield* Effect11.tryPromise({
+    try: () => fs4.readFile(metaPath, "utf-8"),
+    catch: (e) => new VectorStoreError({
+      operation: "load",
+      message: `Failed to read metadata: ${e instanceof Error ? e.message : String(e)}`,
+      cause: e
+    })
+  }).pipe(Effect11.catchAll(() => Effect11.succeed(null)));
+  if (!metaContent) {
+    return {
+      hasEmbeddings: false,
+      count: 0,
+      provider: "none",
+      dimensions: 0,
+      totalCost: 0,
+      totalTokens: 0
+    };
+  }
+  const meta = yield* Effect11.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
+    })
+  });
+  return {
+    hasEmbeddings: true,
+    count: Object.keys(meta.entries).length,
+    provider: meta.providerModel ? `${meta.provider}:${meta.providerModel}` : meta.provider || "openai",
+    dimensions: meta.dimensions,
+    totalCost: meta.totalCost || 0,
+    totalTokens: meta.totalTokens || 0
+  };
+});
+
+// src/search/searcher.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import { Effect as Effect12 } from "effect";
+
+// src/search/fuzzy-search.ts
+import { stemmer } from "stemmer";
+var stem = (word) => {
+  return stemmer(word.toLowerCase());
+};
+var levenshteinDistance = (a, b) => {
+  const matrix = [];
+  for (let i = 0; i <= a.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= b.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        // deletion
+        matrix[i][j - 1] + 1,
+        // insertion
+        matrix[i - 1][j - 1] + cost
+        // substitution
+      );
+    }
+  }
+  return matrix[a.length][b.length];
+};
+var isFuzzyMatch = (word1, word2, maxDistance = 2) => {
+  if (Math.abs(word1.length - word2.length) > maxDistance) {
+    return false;
+  }
+  return levenshteinDistance(word1.toLowerCase(), word2.toLowerCase()) <= maxDistance;
+};
+var matchesWithOptions = (query, text, options = {}) => {
+  const { stem: useStemming, fuzzyDistance } = options;
+  const queryWords = query.toLowerCase().split(/[\W_]+/).filter((w) => w.length > 0);
+  const textWords = text.toLowerCase().split(/[\W_]+/).filter((w) => w.length > 0);
+  if (queryWords.length === 0) {
+    return true;
+  }
+  for (const queryWord of queryWords) {
+    let found = false;
+    for (const textWord of textWords) {
+      if (textWord === queryWord) {
+        found = true;
+        break;
+      }
+      if (useStemming) {
+        if (stem(textWord) === stem(queryWord)) {
+          found = true;
+          break;
+        }
+      }
+      if (fuzzyDistance !== void 0 && fuzzyDistance > 0) {
+        if (isFuzzyMatch(textWord, queryWord, fuzzyDistance)) {
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      return false;
+    }
+  }
+  return true;
+};
+var findMatchesInLine = (queryWords, line, options = {}) => {
+  const { stem: useStemming, fuzzyDistance } = options;
+  const matchesSet = /* @__PURE__ */ new Set();
+  const lineWords = line.toLowerCase().split(/[\W_]+/).filter((w) => w.length > 0);
+  for (const queryWord of queryWords) {
+    const queryLower = queryWord.toLowerCase();
+    const queryStem = useStemming ? stem(queryWord) : null;
+    for (const lineWord of lineWords) {
+      if (matchesSet.has(lineWord)) {
+        continue;
+      }
+      if (lineWord === queryLower) {
+        matchesSet.add(lineWord);
+        continue;
+      }
+      if (queryStem && stem(lineWord) === queryStem) {
+        matchesSet.add(lineWord);
+        continue;
+      }
+      if (fuzzyDistance !== void 0 && fuzzyDistance > 0 && isFuzzyMatch(lineWord, queryLower, fuzzyDistance)) {
+        matchesSet.add(lineWord);
+      }
+    }
+  }
+  return Array.from(matchesSet);
+};
+var buildFuzzyHighlightPattern = (query, options = {}) => {
+  const { stem: useStemming } = options;
+  const queryWords = query.toLowerCase().split(/[\W_]+/).filter((w) => w.length > 0);
+  if (queryWords.length === 0) {
+    return /.^/;
+  }
+  const patterns = [];
+  for (const word of queryWords) {
+    const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (useStemming) {
+      const wordStem = stem(word);
+      const escapedStem = wordStem.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      patterns.push(`\\b${escapedStem}\\w*\\b`);
+    } else {
+      patterns.push(`\\b${escaped}\\b`);
+    }
+  }
+  return new RegExp(patterns.join("|"), "gi");
+};
+
+// src/search/path-matcher.ts
+var matchPath = (filePath, pattern) => {
+  const DOUBLE_STAR_PLACEHOLDER = "__DOUBLE_STAR_MARKER__";
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, DOUBLE_STAR_PLACEHOLDER).replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(new RegExp(DOUBLE_STAR_PLACEHOLDER, "g"), ".*");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(filePath);
+};
+
+// 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 search = (rootPath, options = {}) => Effect12.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 = {}) => Effect12.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;
+  const matchOptions = {
+    stem: options.stem,
+    fuzzyDistance: options.fuzzy ? options.fuzzyDistance ?? 2 : void 0
+  };
+  const useFuzzyOrStem = options.fuzzy || options.stem;
+  if (options.content) {
+    if (isAdvancedQuery(options.content)) {
+      parsedQuery = parseQuery(options.content);
+      if (parsedQuery) {
+        if (useFuzzyOrStem) {
+          highlightRegex = buildFuzzyHighlightPattern(
+            options.content,
+            matchOptions
+          );
+        } else {
+          highlightRegex = buildHighlightPattern(parsedQuery);
+        }
+      }
+    } else {
+      if (!useFuzzyOrStem) {
+        contentRegex = new RegExp(options.content, "gi");
+        highlightRegex = contentRegex;
+      } else {
+        highlightRegex = buildFuzzyHighlightPattern(
+          options.content,
+          matchOptions
+        );
+      }
+    }
+  }
+  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 || useFuzzyOrStem && options.content) {
+      const filePath = path5.join(storage.rootPath, docPath);
+      try {
+        fileContent = yield* Effect12.promise(
+          () => fs5.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 || useFuzzyOrStem) && fileContent) {
+        const sectionLines = fileLines.slice(
+          section.startLine - 1,
+          section.endLine
+        );
+        const sectionContent = sectionLines.join("\n");
+        if (parsedQuery) {
+          if (!evaluateQuery(parsedQuery.ast, sectionContent)) {
+            continue;
+          }
+        }
+        if (useFuzzyOrStem && !parsedQuery && options.content) {
+          if (!matchesWithOptions(options.content, sectionContent, matchOptions)) {
+            continue;
+          }
+        }
+        const matches = [];
+        const searchRegex = contentRegex || highlightRegex;
+        const contextBefore = options.contextBefore ?? 1;
+        const contextAfter = options.contextAfter ?? 1;
+        const queryWords = options.content ? options.content.toLowerCase().split(/\W+/).filter((w) => w.length > 0) : [];
+        for (let i = 0; i < sectionLines.length; i++) {
+          const line = sectionLines[i];
+          if (!line) continue;
+          let isMatch = false;
+          if (searchRegex) {
+            if (searchRegex.test(line)) {
+              isMatch = true;
+            }
+            searchRegex.lastIndex = 0;
+          }
+          if (!isMatch && useFuzzyOrStem && queryWords.length > 0) {
+            const lineMatches = findMatchesInLine(
+              queryWords,
+              line,
+              matchOptions
+            );
+            if (lineMatches.length > 0) {
+              isMatch = true;
+            }
+          }
+          if (isMatch) {
+            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 && !useFuzzyOrStem) {
+        results.push({ section, document });
+        if (options.limit !== void 0 && results.length >= options.limit) {
+          return results;
+        }
+      }
+    }
+  }
+  return results;
+});
+
+export {
+  CONFIG_FILE_NAMES,
+  findConfigFile,
+  loadConfigFile,
+  readEnvConfig,
+  createConfigProvider,
+  createConfigProviderSync,
+  ConfigService,
+  ConfigServiceDefault,
+  buildSectionList,
+  formatSectionList,
+  filterExcludedSections,
+  extractSectionContent,
+  formatExtractedSections,
+  formatSummary,
+  formatAssembledContext,
+  summarizeFile,
+  assembleContext,
+  checkPricingFreshness,
+  getPricingDate,
+  estimateEmbeddingCost,
+  buildEmbeddings,
+  semanticSearch,
+  semanticSearchWithStats,
+  getEmbeddingStats,
+  matchPath,
+  parseQuery,
+  isAdvancedQuery,
+  evaluateQuery,
+  search,
+  searchContent
+};