@arabold/docs-mcp-server 1.13.0 → 1.15.0

package/dist/DocumentManagementService-BGW9iWNn.js

@@ -1,3481 +0,0 @@
-import { v4 } from "uuid";
-import psl from "psl";
-import axios from "axios";
-import { HeaderGenerator } from "header-generator";
-import fs from "node:fs/promises";
-import path from "node:path";
-import * as cheerio from "cheerio";
-import "node:vm";
-import { VirtualConsole, JSDOM } from "jsdom";
-import { chromium } from "playwright";
-import { gfm } from "@joplin/turndown-plugin-gfm";
-import TurndownService from "turndown";
-import { TextDecoder } from "node:util";
-import { URL as URL$1, fileURLToPath } from "node:url";
-import * as semver from "semver";
-import semver__default from "semver";
-import fs$1 from "node:fs";
-import envPaths from "env-paths";
-import Fuse from "fuse.js";
-import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
-import remarkGfm from "remark-gfm";
-import remarkHtml from "remark-html";
-import remarkParse from "remark-parse";
-import { unified } from "unified";
-import Database from "better-sqlite3";
-import * as sqliteVec from "sqlite-vec";
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
-  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
-  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
-  LogLevel2[LogLevel2["DEBUG"] = 3] = "DEBUG";
-  return LogLevel2;
-})(LogLevel || {});
-let currentLogLevel = 2;
-function setLogLevel(level) {
-  currentLogLevel = level;
-}
-const logger = {
-  /**
-   * Logs a debug message if the current log level is DEBUG or higher.
-   * @param message - The message to log.
-   */
-  debug: (message) => {
-    if (currentLogLevel >= 3) {
-      console.debug(message);
-    }
-  },
-  /**
-   * Logs an info message if the current log level is INFO or higher.
-   * @param message - The message to log.
-   */
-  info: (message) => {
-    if (currentLogLevel >= 2) {
-      console.log(message);
-    }
-  },
-  /**
-   * Logs a warning message if the current log level is WARN or higher.
-   * @param message - The message to log.
-   */
-  warn: (message) => {
-    if (currentLogLevel >= 1) {
-      console.warn(message);
-    }
-  },
-  /**
-   * Logs an error message if the current log level is ERROR or higher (always logs).
-   * @param message - The message to log.
-   */
-  error: (message) => {
-    if (currentLogLevel >= 0) {
-      console.error(message);
-    }
-  }
-};
-class ScraperError extends Error {
-  constructor(message, isRetryable = false, cause) {
-    super(message);
-    this.isRetryable = isRetryable;
-    this.cause = cause;
-    this.name = this.constructor.name;
-    if (cause?.stack) {
-      this.stack = `${this.stack}
-Caused by: ${cause.stack}`;
-    }
-  }
-}
-class InvalidUrlError extends ScraperError {
-  constructor(url, cause) {
-    super(`Invalid URL: ${url}`, false, cause);
-  }
-}
-class RedirectError extends ScraperError {
-  constructor(originalUrl, redirectUrl, statusCode) {
-    super(
-      `Redirect detected from ${originalUrl} to ${redirectUrl} (status: ${statusCode})`,
-      false
-    );
-    this.originalUrl = originalUrl;
-    this.redirectUrl = redirectUrl;
-    this.statusCode = statusCode;
-  }
-}
-const defaultNormalizerOptions = {
-  ignoreCase: true,
-  removeHash: true,
-  removeTrailingSlash: true,
-  removeQuery: false,
-  removeIndex: true
-};
-function normalizeUrl(url, options = defaultNormalizerOptions) {
-  try {
-    const parsedUrl = new URL(url);
-    const finalOptions = { ...defaultNormalizerOptions, ...options };
-    const normalized = new URL(parsedUrl.origin + parsedUrl.pathname);
-    if (finalOptions.removeIndex) {
-      normalized.pathname = normalized.pathname.replace(
-        /\/index\.(html|htm|asp|php|jsp)$/i,
-        "/"
-      );
-    }
-    if (finalOptions.removeTrailingSlash && normalized.pathname.length > 1) {
-      normalized.pathname = normalized.pathname.replace(/\/+$/, "");
-    }
-    const preservedHash = !finalOptions.removeHash ? parsedUrl.hash : "";
-    const preservedSearch = !finalOptions.removeQuery ? parsedUrl.search : "";
-    let result = normalized.origin + normalized.pathname;
-    if (preservedSearch) {
-      result += preservedSearch;
-    }
-    if (preservedHash) {
-      result += preservedHash;
-    }
-    if (finalOptions.ignoreCase) {
-      result = result.toLowerCase();
-    }
-    return result;
-  } catch {
-    return url;
-  }
-}
-function validateUrl(url) {
-  try {
-    new URL(url);
-  } catch (error) {
-    throw new InvalidUrlError(url, error instanceof Error ? error : void 0);
-  }
-}
-function hasSameHostname(urlA, urlB) {
-  return urlA.hostname.toLowerCase() === urlB.hostname.toLowerCase();
-}
-function hasSameDomain(urlA, urlB) {
-  const domainA = psl.get(urlA.hostname.toLowerCase());
-  const domainB = psl.get(urlB.hostname.toLowerCase());
-  return domainA !== null && domainA === domainB;
-}
-function isSubpath(baseUrl, targetUrl) {
-  const basePath = baseUrl.pathname.endsWith("/") ? baseUrl.pathname : `${baseUrl.pathname}/`;
-  return targetUrl.pathname.startsWith(basePath);
-}
-const DEFAULT_MAX_PAGES$1 = 1e3;
-const DEFAULT_MAX_DEPTH$1 = 3;
-const DEFAULT_MAX_CONCURRENCY = 3;
-const DEFAULT_PROTOCOL = "stdio";
-const DEFAULT_HTTP_PORT = 6280;
-const DEFAULT_WEB_PORT = 6281;
-const FETCHER_MAX_RETRIES = 6;
-const FETCHER_BASE_DELAY = 1e3;
-const SPLITTER_MIN_CHUNK_SIZE = 500;
-const SPLITTER_PREFERRED_CHUNK_SIZE = 1500;
-const SPLITTER_MAX_CHUNK_SIZE = 5e3;
-const EMBEDDING_BATCH_SIZE = 300;
-class MimeTypeUtils {
-  /**
-   * Parses a Content-Type header string into its MIME type and charset.
-   * @param contentTypeHeader The Content-Type header string (e.g., "text/html; charset=utf-8").
-   * @returns A ParsedContentType object, or a default if parsing fails.
-   */
-  static parseContentType(contentTypeHeader) {
-    if (!contentTypeHeader) {
-      return { mimeType: "application/octet-stream" };
-    }
-    const parts = contentTypeHeader.split(";").map((part) => part.trim());
-    const mimeType = parts[0].toLowerCase();
-    let charset;
-    for (let i = 1; i < parts.length; i++) {
-      const param = parts[i];
-      if (param.toLowerCase().startsWith("charset=")) {
-        charset = param.substring("charset=".length).toLowerCase();
-        break;
-      }
-    }
-    return { mimeType, charset };
-  }
-  /**
-   * Checks if a MIME type represents HTML content.
-   */
-  static isHtml(mimeType) {
-    return mimeType === "text/html" || mimeType === "application/xhtml+xml";
-  }
-  /**
-   * Checks if a MIME type represents Markdown content.
-   */
-  static isMarkdown(mimeType) {
-    return mimeType === "text/markdown" || mimeType === "text/x-markdown";
-  }
-  /**
-   * Checks if a MIME type represents plain text content.
-   */
-  static isText(mimeType) {
-    return mimeType.startsWith("text/");
-  }
-  // Extend with more helpers as needed (isJson, isXml, isPdf, etc.)
-}
-class FingerprintGenerator {
-  headerGenerator;
-  /**
-   * Creates an instance of FingerprintGenerator.
-   * @param options Optional configuration for the header generator.
-   */
-  constructor(options) {
-    const defaultOptions = {
-      browsers: [{ name: "chrome", minVersion: 100 }, "firefox", "safari"],
-      devices: ["desktop", "mobile"],
-      operatingSystems: ["windows", "linux", "macos", "android", "ios"],
-      locales: ["en-US", "en"],
-      httpVersion: "2"
-    };
-    this.headerGenerator = new HeaderGenerator({
-      ...defaultOptions,
-      ...options
-    });
-  }
-  /**
-   * Generates a set of realistic HTTP headers.
-   * @returns A set of realistic HTTP headers.
-   */
-  generateHeaders() {
-    return this.headerGenerator.getHeaders();
-  }
-}
-class HttpFetcher {
-  retryableStatusCodes = [
-    408,
-    // Request Timeout
-    429,
-    // Too Many Requests
-    500,
-    // Internal Server Error
-    502,
-    // Bad Gateway
-    503,
-    // Service Unavailable
-    504,
-    // Gateway Timeout
-    525
-    // SSL Handshake Failed (Cloudflare specific)
-  ];
-  fingerprintGenerator;
-  constructor() {
-    this.fingerprintGenerator = new FingerprintGenerator();
-  }
-  canFetch(source) {
-    return source.startsWith("http://") || source.startsWith("https://");
-  }
-  async delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  async fetch(source, options) {
-    const maxRetries = options?.maxRetries ?? FETCHER_MAX_RETRIES;
-    const baseDelay = options?.retryDelay ?? FETCHER_BASE_DELAY;
-    const followRedirects = options?.followRedirects ?? true;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const fingerprint = this.fingerprintGenerator.generateHeaders();
-        const headers = {
-          ...fingerprint,
-          ...options?.headers
-          // User-provided headers override generated ones
-        };
-        const config = {
-          responseType: "arraybuffer",
-          // For handling both text and binary
-          headers,
-          timeout: options?.timeout,
-          signal: options?.signal,
-          // Pass signal to axios
-          // Axios follows redirects by default, we need to explicitly disable it if needed
-          maxRedirects: followRedirects ? 5 : 0
-        };
-        const response = await axios.get(source, config);
-        const contentTypeHeader = response.headers["content-type"];
-        const { mimeType, charset } = MimeTypeUtils.parseContentType(contentTypeHeader);
-        const contentEncoding = response.headers["content-encoding"];
-        return {
-          content: response.data,
-          mimeType,
-          charset,
-          encoding: contentEncoding,
-          source
-        };
-      } catch (error) {
-        const axiosError = error;
-        const status = axiosError.response?.status;
-        const code = axiosError.code;
-        if (!followRedirects && status && status >= 300 && status < 400) {
-          const location = axiosError.response?.headers?.location;
-          if (location) {
-            throw new RedirectError(source, location, status);
-          }
-        }
-        if (attempt < maxRetries && (status === void 0 || this.retryableStatusCodes.includes(status))) {
-          const delay = baseDelay * 2 ** attempt;
-          logger.warn(
-            `Attempt ${attempt + 1}/${maxRetries + 1} failed for ${source} (Status: ${status}, Code: ${code}). Retrying in ${delay}ms...`
-          );
-          await this.delay(delay);
-          continue;
-        }
-        throw new ScraperError(
-          `Failed to fetch ${source} after ${attempt + 1} attempts: ${axiosError.message ?? "Unknown error"}`,
-          true,
-          error instanceof Error ? error : void 0
-        );
-      }
-    }
-    throw new ScraperError(
-      `Failed to fetch ${source} after ${maxRetries + 1} attempts`,
-      true
-    );
-  }
-}
-class FileFetcher {
-  canFetch(source) {
-    return source.startsWith("file://");
-  }
-  async fetch(source, options) {
-    const filePath = source.replace(/^file:\/\//, "");
-    logger.info(`Fetching file: ${filePath}`);
-    try {
-      const content = await fs.readFile(filePath);
-      const ext = path.extname(filePath).toLowerCase();
-      const mimeType = this.getMimeType(ext);
-      return {
-        content,
-        mimeType,
-        source,
-        encoding: "utf-8"
-        // Assume UTF-8 for text files
-      };
-    } catch (error) {
-      throw new ScraperError(
-        `Failed to read file ${filePath}: ${error.message ?? "Unknown error"}`,
-        false,
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  getMimeType(ext) {
-    switch (ext) {
-      case ".html":
-      case ".htm":
-        return "text/html";
-      case ".md":
-        return "text/markdown";
-      case ".txt":
-        return "text/plain";
-      default:
-        return "application/octet-stream";
-    }
-  }
-}
-class HtmlCheerioParserMiddleware {
-  async process(context, next) {
-    try {
-      logger.debug(`Parsing HTML content with Cheerio from ${context.source}`);
-      const $ = cheerio.load(context.content);
-      context.dom = $;
-      await next();
-    } catch (error) {
-      logger.error(`Failed to parse HTML with Cheerio for ${context.source}: ${error}`);
-      context.errors.push(
-        error instanceof Error ? error : new Error(`Cheerio HTML parsing failed: ${String(error)}`)
-      );
-      return;
-    }
-  }
-}
-function createJSDOM(html, options) {
-  const virtualConsole = new VirtualConsole();
-  virtualConsole.on("error", () => {
-  });
-  virtualConsole.on("warn", () => {
-  });
-  virtualConsole.on("info", () => {
-  });
-  virtualConsole.on("debug", () => {
-  });
-  virtualConsole.on("log", () => {
-  });
-  const defaultOptions = {
-    virtualConsole
-  };
-  const finalOptions = { ...defaultOptions, ...options };
-  return new JSDOM(html, finalOptions);
-}
-class HtmlLinkExtractorMiddleware {
-  /**
-   * Processes the context to extract links from the sanitized HTML body.
-   * @param context The current middleware context.
-   * @param next Function to call the next middleware.
-   */
-  async process(context, next) {
-    const $ = context.dom;
-    if (!$) {
-      logger.warn(
-        `Skipping ${this.constructor.name}: context.dom is missing. Ensure HtmlCheerioParserMiddleware runs before this.`
-      );
-      await next();
-      return;
-    }
-    try {
-      const linkElements = $("a[href]");
-      logger.debug(`Found ${linkElements.length} potential links in ${context.source}`);
-      const extractedLinks = [];
-      linkElements.each((index, element) => {
-        const href = $(element).attr("href");
-        if (href && href.trim() !== "") {
-          try {
-            const urlObj = new URL(href, context.source);
-            if (!["http:", "https:", "file:"].includes(urlObj.protocol)) {
-              logger.debug(`Ignoring link with invalid protocol: ${href}`);
-              return;
-            }
-            extractedLinks.push(urlObj.href);
-          } catch (e) {
-            logger.debug(`Ignoring invalid URL syntax: ${href}`);
-          }
-        }
-      });
-      context.links = [...new Set(extractedLinks)];
-      logger.debug(
-        `Extracted ${context.links.length} unique, valid links from ${context.source}`
-      );
-    } catch (error) {
-      logger.error(`Error extracting links from ${context.source}: ${error}`);
-      context.errors.push(
-        new Error(
-          `Failed to extract links from HTML: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-    await next();
-  }
-}
-class HtmlMetadataExtractorMiddleware {
-  /**
-   * Processes the context to extract the HTML title.
-   * @param context The current processing context.
-   * @param next Function to call the next middleware.
-   */
-  async process(context, next) {
-    const $ = context.dom;
-    if (!$) {
-      logger.warn(
-        `Skipping ${this.constructor.name}: context.dom is missing. Ensure HtmlCheerioParserMiddleware runs before this.`
-      );
-      await next();
-      return;
-    }
-    try {
-      let title = $("title").first().text().trim();
-      if (!title) {
-        title = $("h1").first().text().trim();
-      }
-      title = title || "Untitled";
-      title = title.replace(/\s+/g, " ").trim();
-      context.metadata.title = title;
-      logger.debug(`Extracted title: "${title}" from ${context.source}`);
-    } catch (error) {
-      logger.error(`Error extracting metadata from ${context.source}: ${error}`);
-      context.errors.push(
-        new Error(
-          `Failed to extract metadata from HTML: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-    await next();
-  }
-}
-var ScrapeMode = /* @__PURE__ */ ((ScrapeMode2) => {
-  ScrapeMode2["Fetch"] = "fetch";
-  ScrapeMode2["Playwright"] = "playwright";
-  ScrapeMode2["Auto"] = "auto";
-  return ScrapeMode2;
-})(ScrapeMode || {});
-class HtmlPlaywrightMiddleware {
-  browser = null;
-  /**
-   * Initializes the Playwright browser instance.
-   * Consider making this more robust (e.g., lazy initialization, singleton).
-   */
-  async ensureBrowser() {
-    if (!this.browser || !this.browser.isConnected()) {
-      const launchArgs = process.env.PLAYWRIGHT_LAUNCH_ARGS?.split(" ") ?? [];
-      logger.debug(
-        `Launching new Playwright browser instance (Chromium) with args: ${launchArgs.join(" ") || "none"}...`
-      );
-      this.browser = await chromium.launch({ channel: "chromium", args: launchArgs });
-      this.browser.on("disconnected", () => {
-        logger.debug("Playwright browser instance disconnected.");
-        this.browser = null;
-      });
-    }
-    return this.browser;
-  }
-  /**
-   * Closes the Playwright browser instance if it exists.
-   * Should be called during application shutdown.
-   */
-  async closeBrowser() {
-    if (this.browser?.isConnected()) {
-      logger.debug("Closing Playwright browser instance...");
-      await this.browser.close();
-      this.browser = null;
-    }
-  }
-  async process(context, next) {
-    const scrapeMode = context.options?.scrapeMode ?? ScrapeMode.Auto;
-    const shouldRunPlaywright = scrapeMode === ScrapeMode.Playwright || scrapeMode === ScrapeMode.Auto;
-    if (!shouldRunPlaywright) {
-      logger.debug(
-        `Skipping Playwright rendering for ${context.source} as scrapeMode is '${scrapeMode}'.`
-      );
-      await next();
-      return;
-    }
-    logger.debug(
-      `Running Playwright rendering for ${context.source} (scrapeMode: '${scrapeMode}')`
-    );
-    let page = null;
-    let renderedHtml = null;
-    try {
-      const browser = await this.ensureBrowser();
-      page = await browser.newPage();
-      logger.debug(`Playwright: Processing ${context.source}`);
-      await page.route("**/*", (route) => {
-        if (route.request().url() === context.source) {
-          return route.fulfill({
-            status: 200,
-            contentType: "text/html",
-            body: context.content
-          });
-        }
-        const resourceType = route.request().resourceType();
-        if (["image", "stylesheet", "font", "media"].includes(resourceType)) {
-          return route.abort();
-        }
-        return route.continue();
-      });
-      await page.goto(context.source, {
-        waitUntil: "load"
-      });
-      renderedHtml = await page.content();
-      logger.debug(`Playwright: Successfully rendered content for ${context.source}`);
-    } catch (error) {
-      logger.error(`Playwright failed to render ${context.source}: ${error}`);
-      context.errors.push(
-        error instanceof Error ? error : new Error(`Playwright rendering failed: ${String(error)}`)
-      );
-    } finally {
-      if (page) {
-        await page.unroute("**/*");
-        await page.close();
-      }
-    }
-    if (renderedHtml !== null) {
-      context.content = renderedHtml;
-      logger.debug(
-        `Playwright middleware updated content for ${context.source}. Proceeding.`
-      );
-    } else {
-      logger.warn(
-        `Playwright rendering resulted in null content for ${context.source}. Proceeding without content update.`
-      );
-    }
-    await next();
-  }
-}
-class HtmlSanitizerMiddleware {
-  // Default selectors to remove
-  defaultSelectorsToRemove = [
-    "nav",
-    "footer",
-    "script",
-    "style",
-    "noscript",
-    "svg",
-    "link",
-    "meta",
-    "iframe",
-    "header",
-    "button",
-    "input",
-    "textarea",
-    "select",
-    // "form", // Keep commented
-    ".ads",
-    ".advertisement",
-    ".banner",
-    ".cookie-banner",
-    ".cookie-consent",
-    ".hidden",
-    ".hide",
-    ".modal",
-    ".nav-bar",
-    ".overlay",
-    ".popup",
-    ".promo",
-    ".mw-editsection",
-    ".side-bar",
-    ".social-share",
-    ".sticky",
-    "#ads",
-    "#banner",
-    "#cookieBanner",
-    "#modal",
-    "#nav",
-    "#overlay",
-    "#popup",
-    "#sidebar",
-    "#socialMediaBox",
-    "#stickyHeader",
-    "#ad-container",
-    ".ad-container",
-    ".login-form",
-    ".signup-form",
-    ".tooltip",
-    ".dropdown-menu",
-    // ".alert", // Keep commented
-    ".breadcrumb",
-    ".pagination",
-    // '[role="alert"]', // Keep commented
-    '[role="banner"]',
-    '[role="dialog"]',
-    '[role="alertdialog"]',
-    '[role="region"][aria-label*="skip" i]',
-    '[aria-modal="true"]',
-    ".noprint"
-  ];
-  async process(context, next) {
-    const $ = context.dom;
-    if (!$) {
-      logger.warn(
-        `Skipping ${this.constructor.name}: context.dom is missing. Ensure HtmlCheerioParserMiddleware runs before this.`
-      );
-      await next();
-      return;
-    }
-    try {
-      const selectorsToRemove = [
-        ...context.options.excludeSelectors || [],
-        // Use options from the context
-        ...this.defaultSelectorsToRemove
-      ];
-      logger.debug(
-        `Removing elements matching ${selectorsToRemove.length} selectors for ${context.source}`
-      );
-      let removedCount = 0;
-      for (const selector of selectorsToRemove) {
-        try {
-          const elements = $(selector);
-          const count = elements.length;
-          if (count > 0) {
-            elements.remove();
-            removedCount += count;
-          }
-        } catch (selectorError) {
-          logger.warn(
-            `Potentially invalid selector "${selector}" during element removal: ${selectorError}`
-          );
-          context.errors.push(
-            new Error(`Invalid selector "${selector}": ${selectorError}`)
-          );
-        }
-      }
-      logger.debug(`Removed ${removedCount} elements for ${context.source}`);
-    } catch (error) {
-      logger.error(`Error during HTML element removal for ${context.source}: ${error}`);
-      context.errors.push(
-        error instanceof Error ? error : new Error(`HTML element removal failed: ${String(error)}`)
-      );
-    }
-    await next();
-  }
-}
-class HtmlToMarkdownMiddleware {
-  turndownService;
-  constructor() {
-    this.turndownService = new TurndownService({
-      headingStyle: "atx",
-      hr: "---",
-      bulletListMarker: "-",
-      codeBlockStyle: "fenced",
-      emDelimiter: "_",
-      strongDelimiter: "**",
-      linkStyle: "inlined"
-    });
-    this.turndownService.use(gfm);
-    this.addCustomRules();
-  }
-  addCustomRules() {
-    this.turndownService.addRule("pre", {
-      filter: ["pre"],
-      replacement: (content, node) => {
-        const element = node;
-        let language = element.getAttribute("data-language") || "";
-        if (!language) {
-          const highlightElement = element.closest(
-            '[class*="highlight-source-"], [class*="highlight-"], [class*="language-"]'
-          ) || element.querySelector(
-            '[class*="highlight-source-"], [class*="highlight-"], [class*="language-"]'
-          );
-          if (highlightElement) {
-            const className = highlightElement.className;
-            const match = className.match(
-              /(?:highlight-source-|highlight-|language-)(\w+)/
-            );
-            if (match) language = match[1];
-          }
-        }
-        const brElements = Array.from(element.querySelectorAll("br"));
-        for (const br of brElements) {
-          br.replaceWith("\n");
-        }
-        const text = element.textContent || "";
-        return `
-\`\`\`${language}
-${text.replace(/^\n+|\n+$/g, "")}
-\`\`\`
-`;
-      }
-    });
-    this.turndownService.addRule("anchor", {
-      filter: ["a"],
-      replacement: (content, node) => {
-        const href = node.getAttribute("href");
-        if (!content || content === "#") {
-          return "";
-        }
-        if (!href) {
-          return content;
-        }
-        return `[${content}](${href})`;
-      }
-    });
-  }
-  /**
-   * Processes the context to convert the sanitized HTML body node to Markdown.
-   * @param context The current processing context.
-   * @param next Function to call the next middleware.
-   */
-  async process(context, next) {
-    const $ = context.dom;
-    if (!$) {
-      logger.warn(
-        `Skipping ${this.constructor.name}: context.dom is missing. Ensure HtmlCheerioParserMiddleware ran correctly.`
-      );
-      await next();
-      return;
-    }
-    try {
-      logger.debug(`Converting HTML content to Markdown for ${context.source}`);
-      const htmlToConvert = $("body").html() || $.html();
-      const markdown = this.turndownService.turndown(htmlToConvert).trim();
-      if (!markdown) {
-        const warnMsg = `HTML to Markdown conversion resulted in empty content for ${context.source}.`;
-        logger.warn(warnMsg);
-        context.content = "";
-      } else {
-        context.content = markdown;
-        logger.debug(`Successfully converted HTML to Markdown for ${context.source}`);
-      }
-    } catch (error) {
-      logger.error(`Error converting HTML to Markdown for ${context.source}: ${error}`);
-      context.errors.push(
-        new Error(
-          `Failed to convert HTML to Markdown: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-    await next();
-  }
-}
-class MarkdownLinkExtractorMiddleware {
-  /**
-   * Processes the context. Currently a no-op regarding link extraction.
-   * @param context The current processing context.
-   * @param next Function to call the next middleware.
-   */
-  async process(context, next) {
-    if (!Array.isArray(context.links)) {
-      context.links = [];
-    }
-    await next();
-  }
-}
-class MarkdownMetadataExtractorMiddleware {
-  /**
-   * Processes the context to extract the title from Markdown.
-   * @param context The current processing context.
-   * @param next Function to call the next middleware.
-   */
-  async process(context, next) {
-    try {
-      let title = "Untitled";
-      const match = context.content.match(/^#\s+(.*)$/m);
-      if (match?.[1]) {
-        title = match[1].trim();
-      }
-      context.metadata.title = title;
-    } catch (error) {
-      context.errors.push(
-        new Error(
-          `Failed to extract metadata from Markdown: ${error instanceof Error ? error.message : String(error)}`
-        )
-      );
-    }
-    await next();
-  }
-}
-function convertToString(content, charset) {
-  if (Buffer.isBuffer(content)) {
-    const decoder = new TextDecoder(charset || "utf-8");
-    return decoder.decode(content);
-  }
-  return content;
-}
-class BasePipeline {
-  /**
-   * Determines if this pipeline can process the given content.
-   * Must be implemented by derived classes.
-   */
-  canProcess(_rawContent) {
-    throw new Error("Method not implemented.");
-  }
-  /**
-   * Processes the raw content through the pipeline.
-   * Must be implemented by derived classes.
-   */
-  async process(_rawContent, _options, _fetcher) {
-    throw new Error("Method not implemented.");
-  }
-  /**
-   * Executes a middleware stack on the given context.
-   * This is a utility method used by derived pipeline classes.
-   *
-   * @param middleware - The middleware stack to execute
-   * @param context - The context to process
-   */
-  async executeMiddlewareStack(middleware, context) {
-    let index = -1;
-    const dispatch = async (i) => {
-      if (i <= index) throw new Error("next() called multiple times");
-      index = i;
-      const mw = middleware[i];
-      if (!mw) return;
-      await mw.process(context, dispatch.bind(null, i + 1));
-    };
-    try {
-      await dispatch(0);
-    } catch (error) {
-      context.errors.push(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-  /**
-   * Cleans up resources when the pipeline is no longer needed.
-   * Default implementation does nothing.
-   */
-  async close() {
-  }
-}
-class HtmlPipeline extends BasePipeline {
-  playwrightMiddleware;
-  standardMiddleware;
-  constructor() {
-    super();
-    this.playwrightMiddleware = new HtmlPlaywrightMiddleware();
-    this.standardMiddleware = [
-      new HtmlCheerioParserMiddleware(),
-      new HtmlMetadataExtractorMiddleware(),
-      new HtmlLinkExtractorMiddleware(),
-      new HtmlSanitizerMiddleware(),
-      new HtmlToMarkdownMiddleware()
-    ];
-  }
-  canProcess(rawContent) {
-    return MimeTypeUtils.isHtml(rawContent.mimeType);
-  }
-  async process(rawContent, options, fetcher) {
-    const contentString = convertToString(rawContent.content, rawContent.charset);
-    const context = {
-      content: contentString,
-      source: rawContent.source,
-      metadata: {},
-      links: [],
-      errors: [],
-      options,
-      fetcher
-    };
-    let middleware = [...this.standardMiddleware];
-    if (options.scrapeMode === "playwright" || options.scrapeMode === "auto") {
-      middleware = [this.playwrightMiddleware, ...middleware];
-    }
-    await this.executeMiddlewareStack(middleware, context);
-    return {
-      textContent: typeof context.content === "string" ? context.content : "",
-      metadata: context.metadata,
-      links: context.links,
-      errors: context.errors
-    };
-  }
-  async close() {
-    await this.playwrightMiddleware.closeBrowser();
-  }
-}
-class MarkdownPipeline extends BasePipeline {
-  middleware;
-  constructor() {
-    super();
-    this.middleware = [
-      new MarkdownMetadataExtractorMiddleware(),
-      new MarkdownLinkExtractorMiddleware()
-    ];
-  }
-  canProcess(rawContent) {
-    if (!rawContent.mimeType) return false;
-    return MimeTypeUtils.isMarkdown(rawContent.mimeType) || MimeTypeUtils.isText(rawContent.mimeType);
-  }
-  async process(rawContent, options, fetcher) {
-    const contentString = convertToString(rawContent.content, rawContent.charset);
-    const context = {
-      content: contentString,
-      source: rawContent.source,
-      metadata: {},
-      links: [],
-      errors: [],
-      options,
-      fetcher
-    };
-    await this.executeMiddlewareStack(this.middleware, context);
-    return {
-      textContent: typeof context.content === "string" ? context.content : "",
-      metadata: context.metadata,
-      links: context.links,
-      errors: context.errors
-    };
-  }
-  async close() {
-  }
-}
-class PipelineError extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = this.constructor.name;
-    if (cause?.stack) {
-      this.stack = `${this.stack}
-Caused by: ${cause.stack}`;
-    }
-  }
-}
-class PipelineStateError extends PipelineError {
-}
-class CancellationError extends PipelineError {
-  constructor(message = "Operation cancelled") {
-    super(message);
-  }
-}
-const DEFAULT_MAX_PAGES = 100;
-const DEFAULT_MAX_DEPTH = 3;
-const DEFAULT_CONCURRENCY$1 = 3;
-class BaseScraperStrategy {
-  visited = /* @__PURE__ */ new Set();
-  pageCount = 0;
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  // Removed getProcessor method as processing is now handled by strategies using middleware pipelines
-  async processBatch(batch, baseUrl, options, progressCallback, signal) {
-    const results = await Promise.all(
-      batch.map(async (item) => {
-        if (signal?.aborted) {
-          throw new CancellationError("Scraping cancelled during batch processing");
-        }
-        const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
-        if (item.depth > maxDepth) {
-          return [];
-        }
-        try {
-          const result = await this.processItem(item, options, void 0, signal);
-          if (result.document) {
-            this.pageCount++;
-            const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
-            logger.info(
-              `🌐 Scraping page ${this.pageCount}/${maxPages} (depth ${item.depth}/${maxDepth}): ${item.url}`
-            );
-            await progressCallback({
-              pagesScraped: this.pageCount,
-              maxPages,
-              currentUrl: item.url,
-              depth: item.depth,
-              maxDepth,
-              document: result.document
-            });
-          }
-          const nextItems = result.links || [];
-          return nextItems.map((value) => {
-            try {
-              const targetUrl = new URL$1(value, baseUrl);
-              return {
-                url: targetUrl.href,
-                depth: item.depth + 1
-              };
-            } catch (error) {
-              logger.warn(`❌ Invalid URL: ${value}`);
-            }
-            return null;
-          }).filter((item2) => item2 !== null);
-        } catch (error) {
-          if (options.ignoreErrors) {
-            logger.error(`❌ Failed to process ${item.url}: ${error}`);
-            return [];
-          }
-          throw error;
-        }
-      })
-    );
-    const allLinks = results.flat();
-    const uniqueLinks = [];
-    for (const item of allLinks) {
-      const normalizedUrl = normalizeUrl(item.url, this.options.urlNormalizerOptions);
-      if (!this.visited.has(normalizedUrl)) {
-        this.visited.add(normalizedUrl);
-        uniqueLinks.push(item);
-      }
-    }
-    return uniqueLinks;
-  }
-  async scrape(options, progressCallback, signal) {
-    this.visited.clear();
-    this.pageCount = 0;
-    const baseUrl = new URL$1(options.url);
-    const queue = [{ url: options.url, depth: 0 }];
-    this.visited.add(normalizeUrl(options.url, this.options.urlNormalizerOptions));
-    const maxPages = options.maxPages ?? DEFAULT_MAX_PAGES;
-    const maxConcurrency = options.maxConcurrency ?? DEFAULT_CONCURRENCY$1;
-    while (queue.length > 0 && this.pageCount < maxPages) {
-      if (signal?.aborted) {
-        logger.info("Scraping cancelled by signal.");
-        throw new CancellationError("Scraping cancelled by signal");
-      }
-      const remainingPages = maxPages - this.pageCount;
-      if (remainingPages <= 0) {
-        break;
-      }
-      const batchSize = Math.min(
-        maxConcurrency,
-        // Use variable
-        remainingPages,
-        queue.length
-      );
-      const batch = queue.splice(0, batchSize);
-      const newUrls = await this.processBatch(
-        batch,
-        baseUrl,
-        options,
-        progressCallback,
-        signal
-      );
-      queue.push(...newUrls);
-    }
-  }
-}
-class WebScraperStrategy extends BaseScraperStrategy {
-  httpFetcher = new HttpFetcher();
-  shouldFollowLinkFn;
-  htmlPipeline;
-  markdownPipeline;
-  pipelines;
-  constructor(options = {}) {
-    super({ urlNormalizerOptions: options.urlNormalizerOptions });
-    this.shouldFollowLinkFn = options.shouldFollowLink;
-    this.htmlPipeline = new HtmlPipeline();
-    this.markdownPipeline = new MarkdownPipeline();
-    this.pipelines = [this.htmlPipeline, this.markdownPipeline];
-  }
-  canHandle(url) {
-    try {
-      const parsedUrl = new URL(url);
-      return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Determines if a target URL should be followed based on the scope setting.
-   */
-  isInScope(baseUrl, targetUrl, scope) {
-    try {
-      if (scope === "domain") {
-        return hasSameDomain(baseUrl, targetUrl);
-      }
-      if (scope === "hostname") {
-        return hasSameHostname(baseUrl, targetUrl);
-      }
-      return hasSameHostname(baseUrl, targetUrl) && isSubpath(baseUrl, targetUrl);
-    } catch {
-      return false;
-    }
-  }
-  async processItem(item, options, _progressCallback, signal) {
-    const { url } = item;
-    try {
-      const fetchOptions = {
-        signal,
-        followRedirects: options.followRedirects
-      };
-      const rawContent = await this.httpFetcher.fetch(url, fetchOptions);
-      let processed;
-      for (const pipeline of this.pipelines) {
-        if (pipeline.canProcess(rawContent)) {
-          processed = await pipeline.process(rawContent, options, this.httpFetcher);
-          break;
-        }
-      }
-      if (!processed) {
-        logger.warn(
-          `Unsupported content type "${rawContent.mimeType}" for URL ${url}. Skipping processing.`
-        );
-        return { document: void 0, links: [] };
-      }
-      for (const err of processed.errors) {
-        logger.warn(`Processing error for ${url}: ${err.message}`);
-      }
-      if (!processed.textContent || !processed.textContent.trim()) {
-        logger.warn(`No processable content found for ${url} after pipeline execution.`);
-        return { document: void 0, links: processed.links };
-      }
-      const baseUrl = new URL(options.url);
-      const filteredLinks = processed.links.filter((link) => {
-        try {
-          const targetUrl = new URL(link);
-          const scope = options.scope || "subpages";
-          return this.isInScope(baseUrl, targetUrl, scope) && (!this.shouldFollowLinkFn || this.shouldFollowLinkFn(baseUrl, targetUrl));
-        } catch {
-          return false;
-        }
-      });
-      return {
-        document: {
-          content: processed.textContent,
-          metadata: {
-            url,
-            title: typeof processed.metadata.title === "string" ? processed.metadata.title : "Untitled",
-            library: options.library,
-            version: options.version,
-            ...processed.metadata
-          }
-        },
-        links: filteredLinks
-      };
-    } catch (error) {
-      logger.error(`Failed processing page ${url}: ${error}`);
-      throw error;
-    }
-  }
-  /**
-   * Overrides the base scrape method to ensure the Playwright browser is closed
-   * after the scraping process completes or errors out.
-   */
-  async scrape(options, progressCallback, signal) {
-    try {
-      await super.scrape(options, progressCallback, signal);
-    } finally {
-      await this.htmlPipeline.close();
-      await this.markdownPipeline.close();
-    }
-  }
-}
-class GitHubScraperStrategy {
-  defaultStrategy;
-  canHandle(url) {
-    const { hostname } = new URL(url);
-    return ["github.com", "www.github.com"].includes(hostname);
-  }
-  constructor() {
-    const shouldFollowLink = (baseUrl, targetUrl) => {
-      if (this.getRepoPath(baseUrl) !== this.getRepoPath(targetUrl)) {
-        return false;
-      }
-      const path2 = targetUrl.pathname;
-      if (path2 === this.getRepoPath(targetUrl)) {
-        return true;
-      }
-      if (path2.startsWith(`${this.getRepoPath(targetUrl)}/wiki`)) {
-        return true;
-      }
-      if (path2.startsWith(`${this.getRepoPath(targetUrl)}/blob/`) && path2.endsWith(".md")) {
-        return true;
-      }
-      return false;
-    };
-    this.defaultStrategy = new WebScraperStrategy({
-      urlNormalizerOptions: {
-        ignoreCase: true,
-        removeHash: true,
-        removeTrailingSlash: true,
-        removeQuery: true
-        // Remove query parameters like ?tab=readme-ov-file
-      },
-      shouldFollowLink
-    });
-  }
-  getRepoPath(url) {
-    const match = url.pathname.match(/^\/[^/]+\/[^/]+/);
-    return match?.[0] || "";
-  }
-  async scrape(options, progressCallback, signal) {
-    const url = new URL(options.url);
-    if (!url.hostname.includes("github.com")) {
-      throw new Error("URL must be a GitHub URL");
-    }
-    await this.defaultStrategy.scrape(options, progressCallback, signal);
-  }
-}
-class LocalFileStrategy extends BaseScraperStrategy {
-  fileFetcher = new FileFetcher();
-  htmlPipeline;
-  markdownPipeline;
-  pipelines;
-  constructor() {
-    super();
-    this.htmlPipeline = new HtmlPipeline();
-    this.markdownPipeline = new MarkdownPipeline();
-    this.pipelines = [this.htmlPipeline, this.markdownPipeline];
-  }
-  canHandle(url) {
-    return url.startsWith("file://");
-  }
-  async processItem(item, options, _progressCallback, _signal) {
-    const filePath = item.url.replace(/^file:\/\//, "");
-    const stats = await fs.stat(filePath);
-    if (stats.isDirectory()) {
-      const contents = await fs.readdir(filePath);
-      return {
-        links: contents.map((name) => `file://${path.join(filePath, name)}`)
-      };
-    }
-    logger.info(`📄 Processing file ${this.pageCount}/${options.maxPages}: ${filePath}`);
-    const rawContent = await this.fileFetcher.fetch(item.url);
-    let processed;
-    for (const pipeline of this.pipelines) {
-      if (pipeline.canProcess(rawContent)) {
-        processed = await pipeline.process(rawContent, options, this.fileFetcher);
-        break;
-      }
-    }
-    if (!processed) {
-      logger.warn(
-        `Unsupported content type "${rawContent.mimeType}" for file ${filePath}. Skipping processing.`
-      );
-      return { document: void 0, links: [] };
-    }
-    for (const err of processed.errors) {
-      logger.warn(`Processing error for ${filePath}: ${err.message}`);
-    }
-    return {
-      document: {
-        content: typeof processed.textContent === "string" ? processed.textContent : "",
-        metadata: {
-          url: rawContent.source,
-          title: typeof processed.metadata.title === "string" ? processed.metadata.title : "Untitled",
-          library: options.library,
-          version: options.version
-        }
-      }
-    };
-  }
-  async scrape(options, progressCallback, signal) {
-    try {
-      await super.scrape(options, progressCallback, signal);
-    } finally {
-      await this.htmlPipeline.close();
-      await this.markdownPipeline.close();
-    }
-  }
-}
-class NpmScraperStrategy {
-  defaultStrategy;
-  canHandle(url) {
-    const { hostname } = new URL(url);
-    return ["npmjs.org", "npmjs.com", "www.npmjs.com"].includes(hostname);
-  }
-  constructor() {
-    this.defaultStrategy = new WebScraperStrategy({
-      urlNormalizerOptions: {
-        ignoreCase: true,
-        removeHash: true,
-        removeTrailingSlash: true,
-        removeQuery: true
-        // Enable removeQuery for NPM packages
-      }
-    });
-  }
-  async scrape(options, progressCallback, signal) {
-    await this.defaultStrategy.scrape(options, progressCallback, signal);
-  }
-}
-class PyPiScraperStrategy {
-  defaultStrategy;
-  canHandle(url) {
-    const { hostname } = new URL(url);
-    return ["pypi.org", "www.pypi.org"].includes(hostname);
-  }
-  constructor() {
-    this.defaultStrategy = new WebScraperStrategy({
-      urlNormalizerOptions: {
-        ignoreCase: true,
-        removeHash: true,
-        removeTrailingSlash: true,
-        removeQuery: true
-        // Enable removeQuery for PyPI packages
-      }
-    });
-  }
-  async scrape(options, progressCallback, signal) {
-    await this.defaultStrategy.scrape(options, progressCallback, signal);
-  }
-}
-class ScraperRegistry {
-  strategies;
-  constructor() {
-    this.strategies = [
-      new NpmScraperStrategy(),
-      new PyPiScraperStrategy(),
-      new GitHubScraperStrategy(),
-      new WebScraperStrategy(),
-      new LocalFileStrategy()
-    ];
-  }
-  getStrategy(url) {
-    validateUrl(url);
-    const strategy = this.strategies.find((s) => s.canHandle(url));
-    if (!strategy) {
-      throw new ScraperError(`No strategy found for URL: ${url}`);
-    }
-    return strategy;
-  }
-}
-class ScraperService {
-  registry;
-  constructor(registry) {
-    this.registry = registry;
-  }
-  /**
-   * Scrapes content from the provided URL using the appropriate strategy.
-   * Reports progress via callback and handles errors.
-   */
-  async scrape(options, progressCallback, signal) {
-    const strategy = this.registry.getStrategy(options.url);
-    if (!strategy) {
-      throw new ScraperError(`No scraper strategy found for URL: ${options.url}`, false);
-    }
-    await strategy.scrape(options, progressCallback, signal);
-  }
-}
-class PipelineWorker {
-  // Dependencies are passed in, making the worker stateless regarding specific jobs
-  store;
-  scraperService;
-  // Constructor accepts dependencies needed for execution
-  constructor(store, scraperService) {
-    this.store = store;
-    this.scraperService = scraperService;
-  }
-  /**
-   * Executes the given pipeline job.
-   * @param job - The job to execute.
-   * @param callbacks - Callbacks provided by the manager for reporting.
-   */
-  async executeJob(job, callbacks) {
-    const { id: jobId, library, version, options, abortController } = job;
-    const signal = abortController.signal;
-    logger.debug(`[${jobId}] Worker starting job for ${library}@${version}`);
-    try {
-      await this.scraperService.scrape(
-        options,
-        async (progress) => {
-          if (signal.aborted) {
-            throw new CancellationError("Job cancelled during scraping progress");
-          }
-          job.progress = progress;
-          await callbacks.onJobProgress?.(job, progress);
-          if (progress.document) {
-            try {
-              await this.store.addDocument(library, version, {
-                pageContent: progress.document.content,
-                metadata: progress.document.metadata
-              });
-              logger.debug(
-                `[${jobId}] Stored document: ${progress.document.metadata.url}`
-              );
-            } catch (docError) {
-              logger.error(
-                `[${jobId}] Failed to store document ${progress.document.metadata.url}: ${docError}`
-              );
-              await callbacks.onJobError?.(
-                job,
-                docError instanceof Error ? docError : new Error(String(docError)),
-                progress.document
-              );
-            }
-          }
-        },
-        signal
-        // Pass signal to scraper service
-      );
-      if (signal.aborted) {
-        throw new CancellationError("Job cancelled shortly after scraping finished");
-      }
-      logger.debug(`[${jobId}] Worker finished job successfully.`);
-    } catch (error) {
-      logger.warn(`[${jobId}] Worker encountered error: ${error}`);
-      throw error;
-    }
-  }
-  // --- Old methods removed ---
-  // process()
-  // stop()
-  // setCallbacks()
-  // handleScrapingProgress()
-}
-var PipelineJobStatus = /* @__PURE__ */ ((PipelineJobStatus2) => {
-  PipelineJobStatus2["QUEUED"] = "queued";
-  PipelineJobStatus2["RUNNING"] = "running";
-  PipelineJobStatus2["COMPLETED"] = "completed";
-  PipelineJobStatus2["FAILED"] = "failed";
-  PipelineJobStatus2["CANCELLING"] = "cancelling";
-  PipelineJobStatus2["CANCELLED"] = "cancelled";
-  return PipelineJobStatus2;
-})(PipelineJobStatus || {});
-const DEFAULT_CONCURRENCY = 3;
-class PipelineManager {
-  jobMap = /* @__PURE__ */ new Map();
-  jobQueue = [];
-  activeWorkers = /* @__PURE__ */ new Set();
-  isRunning = false;
-  concurrency;
-  callbacks = {};
-  store;
-  scraperService;
-  constructor(store, concurrency = DEFAULT_CONCURRENCY) {
-    this.store = store;
-    this.concurrency = concurrency;
-    const registry = new ScraperRegistry();
-    this.scraperService = new ScraperService(registry);
-  }
-  /**
-   * Registers callback handlers for pipeline manager events.
-   */
-  setCallbacks(callbacks) {
-    this.callbacks = callbacks;
-  }
-  /**
-   * Starts the pipeline manager's worker processing.
-   */
-  async start() {
-    if (this.isRunning) {
-      logger.warn("PipelineManager is already running.");
-      return;
-    }
-    this.isRunning = true;
-    logger.debug(`PipelineManager started with concurrency ${this.concurrency}.`);
-    this._processQueue();
-  }
-  /**
-   * Stops the pipeline manager and attempts to gracefully shut down workers.
-   * Currently, it just stops processing new jobs. Cancellation of active jobs
-   * needs explicit `cancelJob` calls.
-   */
-  async stop() {
-    if (!this.isRunning) {
-      logger.warn("PipelineManager is not running.");
-      return;
-    }
-    this.isRunning = false;
-    logger.debug("PipelineManager stopping. No new jobs will be started.");
-  }
-  /**
-   * Enqueues a new document processing job.
-   */
-  async enqueueJob(library, version, options) {
-    const jobId = v4();
-    const abortController = new AbortController();
-    let resolveCompletion;
-    let rejectCompletion;
-    const completionPromise = new Promise((resolve, reject) => {
-      resolveCompletion = resolve;
-      rejectCompletion = reject;
-    });
-    const job = {
-      id: jobId,
-      library,
-      version,
-      options,
-      status: PipelineJobStatus.QUEUED,
-      progress: null,
-      error: null,
-      createdAt: /* @__PURE__ */ new Date(),
-      startedAt: null,
-      finishedAt: null,
-      abortController,
-      completionPromise,
-      resolveCompletion,
-      rejectCompletion
-    };
-    this.jobMap.set(jobId, job);
-    this.jobQueue.push(jobId);
-    logger.info(`📝 Job enqueued: ${jobId} for ${library}@${version}`);
-    await this.callbacks.onJobStatusChange?.(job);
-    if (this.isRunning) {
-      this._processQueue();
-    }
-    return jobId;
-  }
-  /**
-   * Retrieves the current state of a specific job.
-   */
-  async getJob(jobId) {
-    return this.jobMap.get(jobId);
-  }
-  /**
-   * Retrieves the current state of all jobs (or a subset based on status).
-   */
-  async getJobs(status) {
-    const allJobs = Array.from(this.jobMap.values());
-    if (status) {
-      return allJobs.filter((job) => job.status === status);
-    }
-    return allJobs;
-  }
-  /**
-   * Returns a promise that resolves when the specified job completes, fails, or is cancelled.
-   */
-  async waitForJobCompletion(jobId) {
-    const job = this.jobMap.get(jobId);
-    if (!job) {
-      throw new PipelineStateError(`Job not found: ${jobId}`);
-    }
-    await job.completionPromise;
-  }
-  /**
-   * Attempts to cancel a queued or running job.
-   */
-  async cancelJob(jobId) {
-    const job = this.jobMap.get(jobId);
-    if (!job) {
-      logger.warn(`Attempted to cancel non-existent job: ${jobId}`);
-      return;
-    }
-    switch (job.status) {
-      case PipelineJobStatus.QUEUED:
-        this.jobQueue = this.jobQueue.filter((id) => id !== jobId);
-        job.status = PipelineJobStatus.CANCELLED;
-        job.finishedAt = /* @__PURE__ */ new Date();
-        logger.info(`🚫 Job cancelled (was queued): ${jobId}`);
-        await this.callbacks.onJobStatusChange?.(job);
-        job.rejectCompletion(new PipelineStateError("Job cancelled before starting"));
-        break;
-      case PipelineJobStatus.RUNNING:
-        job.status = PipelineJobStatus.CANCELLING;
-        job.abortController.abort();
-        logger.info(`🚫 Signalling cancellation for running job: ${jobId}`);
-        await this.callbacks.onJobStatusChange?.(job);
-        break;
-      case PipelineJobStatus.COMPLETED:
-      case PipelineJobStatus.FAILED:
-      case PipelineJobStatus.CANCELLED:
-      case PipelineJobStatus.CANCELLING:
-        logger.warn(
-          `Job ${jobId} cannot be cancelled in its current state: ${job.status}`
-        );
-        break;
-      default:
-        logger.error(`Unhandled job status for cancellation: ${job.status}`);
-        break;
-    }
-  }
-  // --- Private Methods ---
-  /**
-   * Processes the job queue, starting new workers if capacity allows.
-   */
-  _processQueue() {
-    if (!this.isRunning) return;
-    while (this.activeWorkers.size < this.concurrency && this.jobQueue.length > 0) {
-      const jobId = this.jobQueue.shift();
-      if (!jobId) continue;
-      const job = this.jobMap.get(jobId);
-      if (!job || job.status !== PipelineJobStatus.QUEUED) {
-        logger.warn(`Skipping job ${jobId} in queue (not found or not queued).`);
-        continue;
-      }
-      this.activeWorkers.add(jobId);
-      job.status = PipelineJobStatus.RUNNING;
-      job.startedAt = /* @__PURE__ */ new Date();
-      this.callbacks.onJobStatusChange?.(job);
-      this._runJob(job).catch((error) => {
-        logger.error(`Unhandled error during job ${jobId} execution: ${error}`);
-        if (job.status !== PipelineJobStatus.FAILED && job.status !== PipelineJobStatus.CANCELLED) {
-          job.status = PipelineJobStatus.FAILED;
-          job.error = error instanceof Error ? error : new Error(String(error));
-          job.finishedAt = /* @__PURE__ */ new Date();
-          this.callbacks.onJobStatusChange?.(job);
-          job.rejectCompletion(job.error);
-        }
-        this.activeWorkers.delete(jobId);
-        this._processQueue();
-      });
-    }
-  }
-  /**
-   * Executes a single pipeline job by delegating to a PipelineWorker.
-   * Handles final status updates and promise resolution/rejection.
-   */
-  async _runJob(job) {
-    const { id: jobId, abortController } = job;
-    const signal = abortController.signal;
-    const worker = new PipelineWorker(this.store, this.scraperService);
-    try {
-      await worker.executeJob(job, this.callbacks);
-      if (signal.aborted) {
-        throw new CancellationError("Job cancelled just before completion");
-      }
-      job.status = PipelineJobStatus.COMPLETED;
-      job.finishedAt = /* @__PURE__ */ new Date();
-      await this.callbacks.onJobStatusChange?.(job);
-      job.resolveCompletion();
-    } catch (error) {
-      if (error instanceof CancellationError || signal.aborted) {
-        job.status = PipelineJobStatus.CANCELLED;
-        job.finishedAt = /* @__PURE__ */ new Date();
-        job.error = error instanceof CancellationError ? error : new CancellationError("Job cancelled by signal");
-        logger.info(`🚫 Job execution cancelled: ${jobId}: ${job.error.message}`);
-        await this.callbacks.onJobStatusChange?.(job);
-        job.rejectCompletion(job.error);
-      } else {
-        job.status = PipelineJobStatus.FAILED;
-        job.error = error instanceof Error ? error : new Error(String(error));
-        job.finishedAt = /* @__PURE__ */ new Date();
-        logger.error(`❌ Job failed: ${jobId}: ${job.error}`);
-        await this.callbacks.onJobStatusChange?.(job);
-        job.rejectCompletion(job.error);
-      }
-    } finally {
-      this.activeWorkers.delete(jobId);
-      this._processQueue();
-    }
-  }
-}
-const fullTrim = (str) => {
-  return str.replace(/^[\s\r\n\t]+|[\s\r\n\t]+$/g, "");
-};
-class SplitterError extends Error {
-}
-class MinimumChunkSizeError extends SplitterError {
-  constructor(size, maxSize) {
-    super(
-      `Cannot split content any further. Content requires minimum chunk size of ${size} bytes, but maximum allowed is ${maxSize} bytes.`
-    );
-  }
-}
-class ContentSplitterError extends SplitterError {
-}
-class CodeContentSplitter {
-  constructor(options) {
-    this.options = options;
-  }
-  async split(content) {
-    const language = content.match(/^```(\w+)\n/)?.[1];
-    const strippedContent = content.replace(/^```(\w*)\n/, "").replace(/```\s*$/, "");
-    const lines = strippedContent.split("\n");
-    const chunks = [];
-    let currentChunkLines = [];
-    for (const line of lines) {
-      const singleLineSize = this.wrap(line, language).length;
-      if (singleLineSize > this.options.chunkSize) {
-        throw new MinimumChunkSizeError(singleLineSize, this.options.chunkSize);
-      }
-      currentChunkLines.push(line);
-      const newChunkContent = this.wrap(currentChunkLines.join("\n"), language);
-      const newChunkSize = newChunkContent.length;
-      if (newChunkSize > this.options.chunkSize && currentChunkLines.length > 1) {
-        const lastLine = currentChunkLines.pop();
-        chunks.push(this.wrap(currentChunkLines.join("\n"), language));
-        currentChunkLines = [lastLine];
-      }
-    }
-    if (currentChunkLines.length > 0) {
-      chunks.push(this.wrap(currentChunkLines.join("\n"), language));
-    }
-    return chunks;
-  }
-  wrap(content, language) {
-    return `\`\`\`${language || ""}
-${content.replace(/\n+$/, "")}
-\`\`\``;
-  }
-}
-class TableContentSplitter {
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Splits table content into chunks while preserving table structure
-   */
-  async split(content) {
-    const parsedTable = this.parseTable(content);
-    if (!parsedTable) {
-      return [content];
-    }
-    const { headers, rows } = parsedTable;
-    const chunks = [];
-    let currentRows = [];
-    for (const row of rows) {
-      const singleRowSize = this.wrap(row, headers).length;
-      if (singleRowSize > this.options.chunkSize) {
-        throw new MinimumChunkSizeError(singleRowSize, this.options.chunkSize);
-      }
-      const newChunkContent = this.wrap([...currentRows, row].join("\n"), headers);
-      const newChunkSize = newChunkContent.length;
-      if (newChunkSize > this.options.chunkSize && currentRows.length > 0) {
-        chunks.push(this.wrap(currentRows.join("\n"), headers));
-        currentRows = [row];
-      } else {
-        currentRows.push(row);
-      }
-    }
-    if (currentRows.length > 0) {
-      chunks.push(this.wrap(currentRows.join("\n"), headers));
-    }
-    return chunks;
-  }
-  wrap(content, headers) {
-    const headerRow = `| ${headers.join(" | ")} |`;
-    const separatorRow = `|${headers.map(() => "---").join("|")}|`;
-    return [headerRow, separatorRow, content].join("\n");
-  }
-  parseTable(content) {
-    const lines = content.trim().split("\n");
-    if (lines.length < 3) return null;
-    const headers = this.parseRow(lines[0]);
-    if (!headers) return null;
-    const separator = lines[1];
-    if (!this.isValidSeparator(separator)) return null;
-    const rows = lines.slice(2).filter((row) => row.trim() !== "");
-    return { headers, separator, rows };
-  }
-  /**
-   * Parses a table row into cells
-   */
-  parseRow(row) {
-    if (!row.includes("|")) return null;
-    return row.split("|").map((cell) => cell.trim()).filter((cell) => cell !== "");
-  }
-  /**
-   * Validates the separator row of the table
-   */
-  isValidSeparator(separator) {
-    return separator.includes("|") && /^\|?[\s-|]+\|?$/.test(separator);
-  }
-}
-class TextContentSplitter {
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Splits text content into chunks while trying to preserve semantic boundaries.
-   * Prefers paragraph breaks, then line breaks, finally falling back to word boundaries.
-   */
-  async split(content) {
-    const trimmedContent = fullTrim(content);
-    if (trimmedContent.length <= this.options.chunkSize) {
-      return [trimmedContent];
-    }
-    const words = trimmedContent.split(/\s+/);
-    const longestWord = words.reduce(
-      (max, word) => word.length > max.length ? word : max
-    );
-    if (longestWord.length > this.options.chunkSize) {
-      throw new MinimumChunkSizeError(longestWord.length, this.options.chunkSize);
-    }
-    const paragraphChunks = this.splitByParagraphs(trimmedContent);
-    if (this.areChunksValid(paragraphChunks)) {
-      return paragraphChunks;
-    }
-    const lineChunks = this.splitByLines(trimmedContent);
-    if (this.areChunksValid(lineChunks)) {
-      return this.mergeChunks(lineChunks, "\n");
-    }
-    const wordChunks = await this.splitByWords(trimmedContent);
-    return this.mergeChunks(wordChunks, " ");
-  }
-  /**
-   * Checks if all chunks are within the maximum size limit
-   */
-  areChunksValid(chunks) {
-    return chunks.every((chunk) => chunk.length <= this.options.chunkSize);
-  }
-  /**
-   * Splits text into chunks by paragraph boundaries (double newlines)
-   */
-  splitByParagraphs(text) {
-    const paragraphs = text.split(/\n\s*\n/).map((p) => fullTrim(p)).filter(Boolean);
-    return paragraphs.filter((chunk) => chunk.length > 2);
-  }
-  /**
-   * Splits text into chunks by line boundaries
-   */
-  splitByLines(text) {
-    const lines = text.split(/\n/).map((line) => fullTrim(line)).filter(Boolean);
-    return lines.filter((chunk) => chunk.length > 1);
-  }
-  /**
-   * Uses LangChain's recursive splitter for word-based splitting as a last resort
-   */
-  async splitByWords(text) {
-    const splitter = new RecursiveCharacterTextSplitter({
-      chunkSize: this.options.chunkSize,
-      chunkOverlap: 0
-    });
-    const chunks = await splitter.splitText(text);
-    return chunks;
-  }
-  /**
-   * Attempts to merge small chunks with previous chunks to minimize fragmentation.
-   * Only merges if combined size is within maxChunkSize.
-   */
-  mergeChunks(chunks, separator) {
-    const mergedChunks = [];
-    let currentChunk = null;
-    for (const chunk of chunks) {
-      if (currentChunk === null) {
-        currentChunk = chunk;
-        continue;
-      }
-      const currentChunkSize = this.getChunkSize(currentChunk);
-      const nextChunkSize = this.getChunkSize(chunk);
-      if (currentChunkSize + nextChunkSize + separator.length <= this.options.chunkSize) {
-        currentChunk = `${currentChunk}${separator}${chunk}`;
-      } else {
-        mergedChunks.push(currentChunk);
-        currentChunk = chunk;
-      }
-    }
-    if (currentChunk) {
-      mergedChunks.push(currentChunk);
-    }
-    return mergedChunks;
-  }
-  getChunkSize(chunk) {
-    return chunk.length;
-  }
-  wrap(content) {
-    return content;
-  }
-}
-class SemanticMarkdownSplitter {
-  constructor(preferredChunkSize, maxChunkSize) {
-    this.preferredChunkSize = preferredChunkSize;
-    this.maxChunkSize = maxChunkSize;
-    this.turndownService = new TurndownService({
-      headingStyle: "atx",
-      hr: "---",
-      bulletListMarker: "-",
-      codeBlockStyle: "fenced",
-      emDelimiter: "_",
-      strongDelimiter: "**",
-      linkStyle: "inlined"
-    });
-    this.turndownService.addRule("table", {
-      filter: ["table"],
-      replacement: (content, node) => {
-        const table = node;
-        const headers = Array.from(table.querySelectorAll("th")).map(
-          (th) => th.textContent?.trim() || ""
-        );
-        const rows = Array.from(table.querySelectorAll("tr")).filter(
-          (tr) => !tr.querySelector("th")
-        );
-        if (headers.length === 0 && rows.length === 0) return "";
-        let markdown = "\n";
-        if (headers.length > 0) {
-          markdown += `| ${headers.join(" | ")} |
-`;
-          markdown += `|${headers.map(() => "---").join("|")}|
-`;
-        }
-        for (const row of rows) {
-          const cells = Array.from(row.querySelectorAll("td")).map(
-            (td) => td.textContent?.trim() || ""
-          );
-          markdown += `| ${cells.join(" | ")} |
-`;
-        }
-        return markdown;
-      }
-    });
-    this.textSplitter = new TextContentSplitter({
-      chunkSize: this.preferredChunkSize
-    });
-    this.codeSplitter = new CodeContentSplitter({
-      chunkSize: this.maxChunkSize
-    });
-    this.tableSplitter = new TableContentSplitter({
-      chunkSize: this.maxChunkSize
-    });
-  }
-  turndownService;
-  textSplitter;
-  codeSplitter;
-  tableSplitter;
-  /**
-   * Main entry point for splitting markdown content
-   */
-  async splitText(markdown) {
-    const html = await this.markdownToHtml(markdown);
-    const dom = await this.parseHtml(html);
-    const sections = await this.splitIntoSections(dom);
-    return this.splitSectionContent(sections);
-  }
-  /**
-   * Step 1: Split document into sections based on H1-H6 headings,
-   * as well as code blocks and tables.
-   */
-  async splitIntoSections(dom) {
-    const body = dom.querySelector("body");
-    if (!body) {
-      throw new Error("Invalid HTML structure: no body element found");
-    }
-    let currentSection = this.createRootSection();
-    const sections = [];
-    const stack = [currentSection];
-    for (const element of Array.from(body.children)) {
-      const headingMatch = element.tagName.match(/H([1-6])/);
-      if (headingMatch) {
-        const level = Number.parseInt(headingMatch[1], 10);
-        const title = fullTrim(element.textContent || "");
-        while (stack.length > 1 && stack[stack.length - 1].level >= level) {
-          stack.pop();
-        }
-        currentSection = {
-          level,
-          path: [
-            ...stack.slice(1).reduce((acc, s) => {
-              const lastPath = s.path[s.path.length - 1];
-              if (lastPath) acc.push(lastPath);
-              return acc;
-            }, []),
-            title
-          ],
-          content: [
-            {
-              type: "heading",
-              text: `${"#".repeat(level)} ${title}`
-            }
-          ]
-        };
-        sections.push(currentSection);
-        stack.push(currentSection);
-      } else if (element.tagName === "PRE") {
-        const code = element.querySelector("code");
-        const language = code?.className.replace("language-", "") || "";
-        const content = code?.textContent || element.textContent || "";
-        const markdown = `${"```"}${language}
-${content}
-${"```"}`;
-        currentSection = {
-          level: currentSection.level,
-          path: currentSection.path,
-          content: [
-            {
-              type: "code",
-              text: markdown
-            }
-          ]
-        };
-        sections.push(currentSection);
-      } else if (element.tagName === "TABLE") {
-        const markdown = fullTrim(this.turndownService.turndown(element.outerHTML));
-        currentSection = {
-          level: currentSection.level,
-          path: currentSection.path,
-          content: [
-            {
-              type: "table",
-              text: markdown
-            }
-          ]
-        };
-        sections.push(currentSection);
-      } else {
-        const markdown = fullTrim(this.turndownService.turndown(element.innerHTML));
-        if (markdown) {
-          currentSection = {
-            level: currentSection.level,
-            path: currentSection.path,
-            content: [
-              {
-                type: "text",
-                text: markdown
-              }
-            ]
-          };
-          sections.push(currentSection);
-        }
-      }
-    }
-    return sections;
-  }
-  /**
-   * Step 2: Split section content into smaller chunks
-   */
-  async splitSectionContent(sections) {
-    const chunks = [];
-    for (const section of sections) {
-      for (const content of section.content) {
-        let splitContent = [];
-        try {
-          switch (content.type) {
-            case "heading":
-            case "text": {
-              splitContent = await this.textSplitter.split(content.text);
-              break;
-            }
-            case "code": {
-              splitContent = await this.codeSplitter.split(content.text);
-              break;
-            }
-            case "table": {
-              splitContent = await this.tableSplitter.split(content.text);
-              break;
-            }
-          }
-        } catch (err) {
-          if (err instanceof MinimumChunkSizeError) {
-            logger.warn(
-              `⚠ Cannot split ${content.type} chunk normally, using RecursiveCharacterTextSplitter: ${err.message}`
-            );
-            const splitter = new RecursiveCharacterTextSplitter({
-              chunkSize: this.maxChunkSize,
-              chunkOverlap: Math.min(20, Math.floor(this.maxChunkSize * 0.1)),
-              // Use more aggressive separators including empty string as last resort
-              separators: [
-                "\n\n",
-                "\n",
-                " ",
-                "	",
-                ".",
-                ",",
-                ";",
-                ":",
-                "-",
-                "(",
-                ")",
-                "[",
-                "]",
-                "{",
-                "}",
-                ""
-              ]
-            });
-            const chunks2 = await splitter.splitText(content.text);
-            if (chunks2.length === 0) {
-              splitContent = [content.text.substring(0, this.maxChunkSize)];
-            } else {
-              splitContent = chunks2;
-            }
-          } else {
-            const errMessage = err instanceof Error ? err.message : String(err);
-            throw new ContentSplitterError(
-              `Failed to split ${content.type} content: ${errMessage}`
-            );
-          }
-        }
-        chunks.push(
-          ...splitContent.map(
-            (text) => ({
-              types: [content.type],
-              content: text,
-              section: {
-                level: section.level,
-                path: section.path
-              }
-            })
-          )
-        );
-      }
-    }
-    return chunks;
-  }
-  /**
-   * Helper to create the root section
-   */
-  createRootSection() {
-    return {
-      level: 0,
-      path: [],
-      content: []
-    };
-  }
-  /**
-   * Convert markdown to HTML using remark
-   */
-  async markdownToHtml(markdown) {
-    const html = await unified().use(remarkParse).use(remarkGfm).use(remarkHtml).process(markdown);
-    return `<!DOCTYPE html>
-      <html>
-        <body>
-          ${String(html)}
-        </body>
-      </html>`;
-  }
-  /**
-   * Parse HTML
-   */
-  async parseHtml(html) {
-    const { window } = createJSDOM(html);
-    return window.document;
-  }
-}
-class GreedySplitter {
-  baseSplitter;
-  minChunkSize;
-  preferredChunkSize;
-  /**
-   * Combines a base document splitter with size constraints to produce optimally-sized chunks.
-   * The base splitter handles the initial semantic splitting, while this class handles
-   * the concatenation strategy.
-   */
-  constructor(baseSplitter, minChunkSize, preferredChunkSize) {
-    this.baseSplitter = baseSplitter;
-    this.minChunkSize = minChunkSize;
-    this.preferredChunkSize = preferredChunkSize;
-  }
-  /**
-   * Uses a greedy concatenation strategy to build optimally-sized chunks. Small chunks
-   * are combined until they reach the minimum size, but splits are preserved at major
-   * section boundaries to maintain document structure. This balances the need for
-   * context with semantic coherence.
-   */
-  async splitText(markdown) {
-    const initialChunks = await this.baseSplitter.splitText(markdown);
-    const concatenatedChunks = [];
-    let currentChunk = null;
-    for (const nextChunk of initialChunks) {
-      if (currentChunk) {
-        if (this.wouldExceedMaxSize(currentChunk, nextChunk)) {
-          concatenatedChunks.push(currentChunk);
-          currentChunk = this.cloneChunk(nextChunk);
-          continue;
-        }
-        if (currentChunk.content.length >= this.minChunkSize && this.startsNewMajorSection(nextChunk)) {
-          concatenatedChunks.push(currentChunk);
-          currentChunk = this.cloneChunk(nextChunk);
-          continue;
-        }
-        currentChunk.content += `
-${nextChunk.content}`;
-        currentChunk.section = this.mergeSectionInfo(currentChunk, nextChunk);
-        currentChunk.types = this.mergeTypes(currentChunk.types, nextChunk.types);
-      } else {
-        currentChunk = this.cloneChunk(nextChunk);
-      }
-    }
-    if (currentChunk) {
-      concatenatedChunks.push(currentChunk);
-    }
-    return concatenatedChunks;
-  }
-  cloneChunk(chunk) {
-    return {
-      types: [...chunk.types],
-      content: chunk.content,
-      section: {
-        level: chunk.section.level,
-        path: [...chunk.section.path]
-      }
-    };
-  }
-  /**
-   * H1 and H2 headings represent major conceptual breaks in the document.
-   * Preserving these splits helps maintain the document's logical structure.
-   */
-  startsNewMajorSection(chunk) {
-    return chunk.section.level === 1 || chunk.section.level === 2;
-  }
-  /**
-   * Size limit check to ensure chunks remain within embedding model constraints.
-   * Essential for maintaining consistent embedding quality and avoiding truncation.
-   */
-  wouldExceedMaxSize(currentChunk, nextChunk) {
-    if (!currentChunk) {
-      return false;
-    }
-    return currentChunk.content.length + nextChunk.content.length > this.preferredChunkSize;
-  }
-  /**
-   * Checks if one path is a prefix of another path, indicating a parent-child relationship
-   */
-  isPathIncluded(parentPath, childPath) {
-    if (parentPath.length >= childPath.length) return false;
-    return parentPath.every((part, i) => part === childPath[i]);
-  }
-  /**
-   * Merges section metadata when concatenating chunks, following these rules:
-   * 1. Level: Always uses the lowest (most general) level between chunks
-   * 2. Path selection:
-   *    - For parent-child relationships (one path includes the other), uses the child's path
-   *    - For siblings/unrelated sections, uses the common parent path
-   *    - If no common path exists, uses the root path ([])
-   */
-  mergeSectionInfo(currentChunk, nextChunk) {
-    const level = Math.min(currentChunk.section.level, nextChunk.section.level);
-    if (currentChunk.section.level === nextChunk.section.level && currentChunk.section.path.length === nextChunk.section.path.length && currentChunk.section.path.every((p, i) => p === nextChunk.section.path[i])) {
-      return currentChunk.section;
-    }
-    if (this.isPathIncluded(currentChunk.section.path, nextChunk.section.path)) {
-      return {
-        path: nextChunk.section.path,
-        level
-      };
-    }
-    if (this.isPathIncluded(nextChunk.section.path, currentChunk.section.path)) {
-      return {
-        path: currentChunk.section.path,
-        level
-      };
-    }
-    const commonPath = this.findCommonPrefix(
-      currentChunk.section.path,
-      nextChunk.section.path
-    );
-    return {
-      path: commonPath,
-      level
-    };
-  }
-  mergeTypes(currentTypes, nextTypes) {
-    return [.../* @__PURE__ */ new Set([...currentTypes, ...nextTypes])];
-  }
-  /**
-   * Returns longest common prefix between two paths
-   */
-  findCommonPrefix(path1, path2) {
-    const common = [];
-    for (let i = 0; i < Math.min(path1.length, path2.length); i++) {
-      if (path1[i] === path2[i]) {
-        common.push(path1[i]);
-      } else {
-        break;
-      }
-    }
-    return common;
-  }
-}
-class ToolError extends Error {
-  constructor(message, toolName) {
-    super(message);
-    this.toolName = toolName;
-    this.name = this.constructor.name;
-  }
-}
-class VersionNotFoundError extends ToolError {
-  constructor(library, requestedVersion, availableVersions) {
-    super(
-      `Version ${requestedVersion} not found for ${library}. Available versions: ${availableVersions.map((v) => v.version).join(", ")}`,
-      "SearchTool"
-    );
-    this.library = library;
-    this.requestedVersion = requestedVersion;
-    this.availableVersions = availableVersions;
-  }
-  getLatestVersion() {
-    return this.availableVersions.sort((a, b) => semver__default.compare(b.version, a.version))[0];
-  }
-}
-class LibraryNotFoundError extends ToolError {
-  constructor(requestedLibrary, suggestions = []) {
-    let message = `Library '${requestedLibrary}' not found.`;
-    if (suggestions.length > 0) {
-      message += ` Did you mean one of these: ${suggestions.join(", ")}?`;
-    }
-    super(message, "SearchTool");
-    this.requestedLibrary = requestedLibrary;
-    this.suggestions = suggestions;
-  }
-}
-class ListLibrariesTool {
-  docService;
-  constructor(docService) {
-    this.docService = docService;
-  }
-  async execute(options) {
-    const rawLibraries = await this.docService.listLibraries();
-    const libraries = rawLibraries.map(({ library, versions }) => ({
-      name: library,
-      versions
-      // Directly assign the detailed versions array
-    }));
-    return { libraries };
-  }
-}
-class ScrapeTool {
-  docService;
-  manager;
-  // Add manager property
-  constructor(docService, manager) {
-    this.docService = docService;
-    this.manager = manager;
-  }
-  async execute(options) {
-    const {
-      library,
-      version,
-      url,
-      options: scraperOptions,
-      waitForCompletion = true
-    } = options;
-    let internalVersion;
-    const partialVersionRegex = /^\d+(\.\d+)?$/;
-    if (version === null || version === void 0) {
-      internalVersion = "";
-    } else {
-      const validFullVersion = semver.valid(version);
-      if (validFullVersion) {
-        internalVersion = validFullVersion;
-      } else if (partialVersionRegex.test(version)) {
-        const coercedVersion = semver.coerce(version);
-        if (coercedVersion) {
-          internalVersion = coercedVersion.version;
-        } else {
-          throw new Error(
-            `Invalid version format for scraping: '${version}'. Use 'X.Y.Z', 'X.Y.Z-prerelease', 'X.Y', 'X', or omit.`
-          );
-        }
-      } else {
-        throw new Error(
-          `Invalid version format for scraping: '${version}'. Use 'X.Y.Z', 'X.Y.Z-prerelease', 'X.Y', 'X', or omit.`
-        );
-      }
-    }
-    internalVersion = internalVersion.toLowerCase();
-    await this.docService.removeAllDocuments(library, internalVersion);
-    logger.info(
-      `💾 Cleared store for ${library}@${internalVersion || "[no version]"} before scraping.`
-    );
-    const manager = this.manager;
-    const jobId = await manager.enqueueJob(library, internalVersion, {
-      url,
-      library,
-      version: internalVersion,
-      scope: scraperOptions?.scope ?? "subpages",
-      followRedirects: scraperOptions?.followRedirects ?? true,
-      maxPages: scraperOptions?.maxPages ?? DEFAULT_MAX_PAGES$1,
-      maxDepth: scraperOptions?.maxDepth ?? DEFAULT_MAX_DEPTH$1,
-      maxConcurrency: scraperOptions?.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY,
-      ignoreErrors: scraperOptions?.ignoreErrors ?? true,
-      scrapeMode: scraperOptions?.scrapeMode ?? ScrapeMode.Auto
-      // Pass scrapeMode enum
-    });
-    if (waitForCompletion) {
-      try {
-        await manager.waitForJobCompletion(jobId);
-        const finalJob = await manager.getJob(jobId);
-        const finalPagesScraped = finalJob?.progress?.pagesScraped ?? 0;
-        logger.debug(
-          `Job ${jobId} finished with status ${finalJob?.status}. Pages scraped: ${finalPagesScraped}`
-        );
-        return {
-          pagesScraped: finalPagesScraped
-        };
-      } catch (error) {
-        logger.error(`Job ${jobId} failed or was cancelled: ${error}`);
-        throw error;
-      }
-    }
-    return { jobId };
-  }
-}
-class SearchTool {
-  docService;
-  constructor(docService) {
-    this.docService = docService;
-  }
-  async execute(options) {
-    const { library, version, query, limit = 5, exactMatch = false } = options;
-    if (exactMatch && (!version || version === "latest")) {
-      await this.docService.validateLibraryExists(library);
-      const allLibraries = await this.docService.listLibraries();
-      const libraryInfo = allLibraries.find((lib) => lib.library === library);
-      const detailedVersions = libraryInfo ? libraryInfo.versions : [];
-      throw new VersionNotFoundError(
-        library,
-        "latest",
-        // Or perhaps the original 'version' if it wasn't 'latest'? Check logic.
-        detailedVersions
-      );
-    }
-    const resolvedVersion = version || "latest";
-    logger.info(
-      `🔍 Searching ${library}@${resolvedVersion} for: ${query}${exactMatch ? " (exact match)" : ""}`
-    );
-    try {
-      await this.docService.validateLibraryExists(library);
-      let versionToSearch = resolvedVersion;
-      if (!exactMatch) {
-        const versionResult = await this.docService.findBestVersion(library, version);
-        versionToSearch = versionResult.bestMatch;
-      }
-      const results = await this.docService.searchStore(
-        library,
-        versionToSearch,
-        query,
-        limit
-      );
-      logger.info(`✅ Found ${results.length} matching results`);
-      return { results };
-    } catch (error) {
-      logger.error(
-        `❌ Search failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-      throw error;
-    }
-  }
-}
-let projectRoot = null;
-function getProjectRoot() {
-  if (projectRoot) {
-    return projectRoot;
-  }
-  const currentFilePath = fileURLToPath(import.meta.url);
-  let currentDir = path.dirname(currentFilePath);
-  while (true) {
-    const packageJsonPath = path.join(currentDir, "package.json");
-    if (fs$1.existsSync(packageJsonPath)) {
-      projectRoot = currentDir;
-      return projectRoot;
-    }
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) {
-      throw new Error("Could not find project root containing package.json.");
-    }
-    currentDir = parentDir;
-  }
-}
-const CHILD_LIMIT = 5;
-const SIBLING_LIMIT = 2;
-class DocumentRetrieverService {
-  documentStore;
-  constructor(documentStore) {
-    this.documentStore = documentStore;
-  }
-  /**
-   * Collects all related chunk IDs for a given initial hit.
-   * Returns an object with url, hitId, relatedIds (Set), and score.
-   */
-  async getRelatedChunkIds(library, version, doc, siblingLimit = SIBLING_LIMIT, childLimit = CHILD_LIMIT) {
-    const id = doc.id;
-    const url = doc.metadata.url;
-    const score = doc.metadata.score;
-    const relatedIds = /* @__PURE__ */ new Set();
-    relatedIds.add(id);
-    const parent = await this.documentStore.findParentChunk(library, version, id);
-    if (parent) {
-      relatedIds.add(parent.id);
-    }
-    const precedingSiblings = await this.documentStore.findPrecedingSiblingChunks(
-      library,
-      version,
-      id,
-      siblingLimit
-    );
-    for (const sib of precedingSiblings) {
-      relatedIds.add(sib.id);
-    }
-    const childChunks = await this.documentStore.findChildChunks(
-      library,
-      version,
-      id,
-      childLimit
-    );
-    for (const child of childChunks) {
-      relatedIds.add(child.id);
-    }
-    const subsequentSiblings = await this.documentStore.findSubsequentSiblingChunks(
-      library,
-      version,
-      id,
-      siblingLimit
-    );
-    for (const sib of subsequentSiblings) {
-      relatedIds.add(sib.id);
-    }
-    return { url, hitId: id, relatedIds, score };
-  }
-  /**
-   * Groups related chunk info by URL, deduplicates IDs, and finds max score per URL.
-   */
-  groupAndPrepareFetch(relatedInfos) {
-    const urlMap = /* @__PURE__ */ new Map();
-    for (const info of relatedInfos) {
-      let entry = urlMap.get(info.url);
-      if (!entry) {
-        entry = { uniqueChunkIds: /* @__PURE__ */ new Set(), maxScore: info.score };
-        urlMap.set(info.url, entry);
-      }
-      for (const id of info.relatedIds) {
-        entry.uniqueChunkIds.add(id);
-      }
-      if (info.score > entry.maxScore) {
-        entry.maxScore = info.score;
-      }
-    }
-    return urlMap;
-  }
-  /**
-   * Finalizes the merged result for a URL group by fetching, sorting, and joining content.
-   */
-  async finalizeResult(library, version, url, uniqueChunkIds, maxScore) {
-    const ids = Array.from(uniqueChunkIds);
-    const docs = await this.documentStore.findChunksByIds(library, version, ids);
-    const content = docs.map((d) => d.pageContent).join("\n\n");
-    return {
-      url,
-      content,
-      score: maxScore
-    };
-  }
-  /**
-   * Searches for documents and expands the context around the matches.
-   * @param library The library name.
-   * @param version The library version.
-   * @param query The search query.
-   * @param version The library version (optional, defaults to searching documents without a version).
-   * @param query The search query.
-   * @param limit The optional limit for the initial search results.
-   * @returns An array of strings representing the aggregated content of the retrieved chunks.
-   */
-  async search(library, version, query, limit) {
-    const normalizedVersion = (version ?? "").toLowerCase();
-    const initialResults = await this.documentStore.findByContent(
-      library,
-      normalizedVersion,
-      query,
-      limit ?? 10
-    );
-    const relatedInfos = await Promise.all(
-      initialResults.map(
-        (doc) => this.getRelatedChunkIds(library, normalizedVersion, doc)
-      )
-    );
-    const urlMap = this.groupAndPrepareFetch(relatedInfos);
-    const results = [];
-    for (const [url, { uniqueChunkIds, maxScore }] of urlMap.entries()) {
-      const result = await this.finalizeResult(
-        library,
-        normalizedVersion,
-        url,
-        uniqueChunkIds,
-        maxScore
-      );
-      results.push(result);
-    }
-    return results;
-  }
-}
-class StoreError extends Error {
-  constructor(message, cause) {
-    super(cause ? `${message} caused by ${cause}` : message);
-    this.cause = cause;
-    this.name = this.constructor.name;
-    const causeError = cause instanceof Error ? cause : cause ? new Error(String(cause)) : void 0;
-    if (causeError?.stack) {
-      this.stack = causeError.stack;
-    }
-  }
-}
-class DimensionError extends StoreError {
-  constructor(modelName, modelDimension, dbDimension) {
-    super(
-      `Model "${modelName}" produces ${modelDimension}-dimensional vectors, which exceeds the database's fixed dimension of ${dbDimension}. Please use a model with dimension ≤ ${dbDimension}.`
-    );
-    this.modelName = modelName;
-    this.modelDimension = modelDimension;
-    this.dbDimension = dbDimension;
-  }
-}
-class ConnectionError extends StoreError {
-}
-const MIGRATIONS_DIR = path.join(getProjectRoot(), "db", "migrations");
-const MIGRATIONS_TABLE = "_schema_migrations";
-function ensureMigrationsTable(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-      id TEXT PRIMARY KEY,
-      applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
-    );
-  `);
-}
-function getAppliedMigrations(db) {
-  const stmt = db.prepare(`SELECT id FROM ${MIGRATIONS_TABLE}`);
-  const rows = stmt.all();
-  return new Set(rows.map((row) => row.id));
-}
-function applyMigrations(db) {
-  try {
-    logger.debug("Applying database migrations...");
-    ensureMigrationsTable(db);
-    const appliedMigrations = getAppliedMigrations(db);
-    if (!fs$1.existsSync(MIGRATIONS_DIR)) {
-      throw new StoreError("Migrations directory not found");
-    }
-    const migrationFiles = fs$1.readdirSync(MIGRATIONS_DIR).filter((file) => file.endsWith(".sql")).sort();
-    let appliedCount = 0;
-    for (const filename of migrationFiles) {
-      if (!appliedMigrations.has(filename)) {
-        logger.debug(`Applying migration: ${filename}`);
-        const filePath = path.join(MIGRATIONS_DIR, filename);
-        const sql = fs$1.readFileSync(filePath, "utf8");
-        const transaction = db.transaction(() => {
-          db.exec(sql);
-          const insertStmt = db.prepare(
-            `INSERT INTO ${MIGRATIONS_TABLE} (id) VALUES (?)`
-          );
-          insertStmt.run(filename);
-        });
-        try {
-          transaction();
-          logger.debug(`Successfully applied migration: ${filename}`);
-          appliedCount++;
-        } catch (error) {
-          logger.error(`Failed to apply migration: ${filename} - ${error}`);
-          throw new StoreError(`Migration failed: ${filename} - ${error}`);
-        }
-      }
-    }
-    if (appliedCount > 0) {
-      logger.debug(`Applied ${appliedCount} new migration(s).`);
-    } else {
-      logger.debug("Database schema is up to date.");
-    }
-  } catch (error) {
-    if (error instanceof StoreError) {
-      throw error;
-    }
-    throw new StoreError("Failed during migration process", error);
-  }
-}
-const VECTOR_DIMENSION = 1536;
-function mapDbDocumentToDocument(doc) {
-  return {
-    id: doc.id,
-    pageContent: doc.content,
-    metadata: JSON.parse(doc.metadata)
-  };
-}
-class DocumentStore {
-  db;
-  embeddings;
-  dbDimension = VECTOR_DIMENSION;
-  modelDimension;
-  statements;
-  /**
-   * Calculates Reciprocal Rank Fusion score for a result
-   */
-  calculateRRF(vecRank, ftsRank, k = 60) {
-    let rrf = 0;
-    if (vecRank !== void 0) {
-      rrf += 1 / (k + vecRank);
-    }
-    if (ftsRank !== void 0) {
-      rrf += 1 / (k + ftsRank);
-    }
-    return rrf;
-  }
-  /**
-   * Assigns ranks to search results based on their scores
-   */
-  assignRanks(results) {
-    const vecRanks = /* @__PURE__ */ new Map();
-    const ftsRanks = /* @__PURE__ */ new Map();
-    results.filter((r) => r.vec_score !== void 0).sort((a, b) => (a.vec_score ?? 0) - (b.vec_score ?? 0)).forEach((result, index) => {
-      vecRanks.set(Number(result.id), index + 1);
-    });
-    results.filter((r) => r.fts_score !== void 0).sort((a, b) => (a.fts_score ?? 0) - (b.fts_score ?? 0)).forEach((result, index) => {
-      ftsRanks.set(Number(result.id), index + 1);
-    });
-    return results.map((result) => ({
-      ...result,
-      vec_rank: vecRanks.get(Number(result.id)),
-      fts_rank: ftsRanks.get(Number(result.id)),
-      rrf_score: this.calculateRRF(
-        vecRanks.get(Number(result.id)),
-        ftsRanks.get(Number(result.id))
-      )
-    }));
-  }
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new StoreError("Missing required database path");
-    }
-    this.db = new Database(dbPath);
-  }
-  /**
-   * Sets up prepared statements for database queries
-   */
-  prepareStatements() {
-    const statements = {
-      getById: this.db.prepare("SELECT * FROM documents WHERE id = ?"),
-      insertDocument: this.db.prepare(
-        "INSERT INTO documents (library, version, url, content, metadata, sort_order, indexed_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
-        // Added indexed_at
-      ),
-      insertEmbedding: this.db.prepare(
-        "INSERT INTO documents_vec (rowid, library, version, embedding) VALUES (?, ?, ?, ?)"
-      ),
-      deleteDocuments: this.db.prepare(
-        "DELETE FROM documents WHERE library = ? AND version = ?"
-      ),
-      queryVersions: this.db.prepare(
-        "SELECT DISTINCT version FROM documents WHERE library = ? ORDER BY version"
-      ),
-      checkExists: this.db.prepare(
-        "SELECT id FROM documents WHERE library = ? AND version = ? LIMIT 1"
-      ),
-      queryLibraryVersions: this.db.prepare(
-        `SELECT
-          library,
-          version,
-          COUNT(*) as documentCount,
-          COUNT(DISTINCT url) as uniqueUrlCount,
-          MIN(indexed_at) as indexedAt
-        FROM documents
-        GROUP BY library, version
-        ORDER BY library, version`
-      ),
-      getChildChunks: this.db.prepare(`
-        SELECT * FROM documents
-        WHERE library = ? 
-        AND version = ? 
-        AND url = ?
-        AND json_array_length(json_extract(metadata, '$.path')) = ?
-        AND json_extract(metadata, '$.path') LIKE ? || '%'
-        AND sort_order > (SELECT sort_order FROM documents WHERE id = ?)
-        ORDER BY sort_order
-        LIMIT ?
-      `),
-      getPrecedingSiblings: this.db.prepare(`
-        SELECT * FROM documents 
-        WHERE library = ? 
-        AND version = ? 
-        AND url = ?
-        AND sort_order < (SELECT sort_order FROM documents WHERE id = ?)
-        AND json_extract(metadata, '$.path') = ?
-        ORDER BY sort_order DESC
-        LIMIT ?
-      `),
-      getSubsequentSiblings: this.db.prepare(`
-        SELECT * FROM documents 
-        WHERE library = ? 
-        AND version = ? 
-        AND url = ?
-        AND sort_order > (SELECT sort_order FROM documents WHERE id = ?)
-        AND json_extract(metadata, '$.path') = ?
-        ORDER BY sort_order
-        LIMIT ?
-      `),
-      getParentChunk: this.db.prepare(`
-        SELECT * FROM documents 
-        WHERE library = ? 
-        AND version = ? 
-        AND url = ?
-        AND json_extract(metadata, '$.path') = ?
-        AND sort_order < (SELECT sort_order FROM documents WHERE id = ?)
-        ORDER BY sort_order DESC
-        LIMIT 1
-      `)
-    };
-    this.statements = statements;
-  }
-  /**
-   * Pads a vector to the fixed database dimension by appending zeros.
-   * Throws an error if the input vector is longer than the database dimension.
-   */
-  padVector(vector) {
-    if (vector.length > this.dbDimension) {
-      throw new Error(
-        `Vector dimension ${vector.length} exceeds database dimension ${this.dbDimension}`
-      );
-    }
-    if (vector.length === this.dbDimension) {
-      return vector;
-    }
-    return [...vector, ...new Array(this.dbDimension - vector.length).fill(0)];
-  }
-  /**
-   * Initializes embeddings client using environment variables for configuration.
-   *
-   * The embedding model is configured using DOCS_MCP_EMBEDDING_MODEL environment variable.
-   * Format: "provider:model_name" (e.g., "google:text-embedding-004") or just "model_name"
-   * for OpenAI (default).
-   *
-   * Supported providers and their required environment variables:
-   * - openai: OPENAI_API_KEY (and optionally OPENAI_API_BASE, OPENAI_ORG_ID)
-   * - google: GOOGLE_APPLICATION_CREDENTIALS (path to service account JSON)
-   * - aws: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION (or BEDROCK_AWS_REGION)
-   * - microsoft: Azure OpenAI credentials (AZURE_OPENAI_API_*)
-   */
-  async initializeEmbeddings() {
-    const modelSpec = process.env.DOCS_MCP_EMBEDDING_MODEL || "text-embedding-3-small";
-    const { createEmbeddingModel } = await import("./EmbeddingFactory-0Z5e_g1J.js");
-    this.embeddings = createEmbeddingModel(modelSpec);
-    const testVector = await this.embeddings.embedQuery("test");
-    this.modelDimension = testVector.length;
-    if (this.modelDimension > this.dbDimension) {
-      throw new DimensionError(modelSpec, this.modelDimension, this.dbDimension);
-    }
-  }
-  /**
-   * Escapes a query string for use with SQLite FTS5 MATCH operator.
-   * Wraps the query in double quotes and escapes internal double quotes.
-   */
-  escapeFtsQuery(query) {
-    const escapedQuotes = query.replace(/"/g, '""');
-    return `"${escapedQuotes}"`;
-  }
-  /**
-   * Initializes database connection and ensures readiness
-   */
-  async initialize() {
-    try {
-      sqliteVec.load(this.db);
-      applyMigrations(this.db);
-      this.prepareStatements();
-      await this.initializeEmbeddings();
-    } catch (error) {
-      if (error instanceof StoreError) {
-        throw error;
-      }
-      throw new ConnectionError("Failed to initialize database connection", error);
-    }
-  }
-  /**
-   * Gracefully closes database connections
-   */
-  async shutdown() {
-    this.db.close();
-  }
-  /**
-   * Retrieves all unique versions for a specific library
-   */
-  async queryUniqueVersions(library) {
-    try {
-      const rows = this.statements.queryVersions.all(library.toLowerCase());
-      return rows.map((row) => row.version);
-    } catch (error) {
-      throw new ConnectionError("Failed to query versions", error);
-    }
-  }
-  /**
-   * Verifies existence of documents for a specific library version
-   */
-  async checkDocumentExists(library, version) {
-    try {
-      const result = this.statements.checkExists.get(
-        library.toLowerCase(),
-        version.toLowerCase()
-      );
-      return result !== void 0;
-    } catch (error) {
-      throw new ConnectionError("Failed to check document existence", error);
-    }
-  }
-  /**
-   * Retrieves a mapping of all libraries to their available versions with details.
-   */
-  async queryLibraryVersions() {
-    try {
-      const rows = this.statements.queryLibraryVersions.all();
-      const libraryMap = /* @__PURE__ */ new Map();
-      for (const row of rows) {
-        const library = row.library;
-        if (!libraryMap.has(library)) {
-          libraryMap.set(library, []);
-        }
-        const indexedAtISO = row.indexedAt ? new Date(row.indexedAt).toISOString() : null;
-        libraryMap.get(library)?.push({
-          version: row.version,
-          documentCount: row.documentCount,
-          uniqueUrlCount: row.uniqueUrlCount,
-          indexedAt: indexedAtISO
-        });
-      }
-      for (const versions of libraryMap.values()) {
-        versions.sort((a, b) => {
-          if (a.version === "" && b.version !== "") {
-            return -1;
-          }
-          if (a.version !== "" && b.version === "") {
-            return 1;
-          }
-          if (a.version === "" && b.version === "") {
-            return 0;
-          }
-          return semver__default.compare(a.version, b.version);
-        });
-      }
-      return libraryMap;
-    } catch (error) {
-      throw new ConnectionError("Failed to query library versions", error);
-    }
-  }
-  /**
-   * Stores documents with library and version metadata, generating embeddings
-   * for vector similarity search
-   */
-  async addDocuments(library, version, documents) {
-    try {
-      const texts = documents.map((doc) => {
-        const header = `<title>${doc.metadata.title}</title>
-<url>${doc.metadata.url}</url>
-<path>${doc.metadata.path.join(" / ")}</path>
-`;
-        return `${header}${doc.pageContent}`;
-      });
-      const rawEmbeddings = [];
-      for (let i = 0; i < texts.length; i += EMBEDDING_BATCH_SIZE) {
-        const batchTexts = texts.slice(i, i + EMBEDDING_BATCH_SIZE);
-        const batchEmbeddings = await this.embeddings.embedDocuments(batchTexts);
-        rawEmbeddings.push(...batchEmbeddings);
-      }
-      const paddedEmbeddings = rawEmbeddings.map((vector) => this.padVector(vector));
-      const transaction = this.db.transaction((docs) => {
-        for (let i = 0; i < docs.length; i++) {
-          const doc = docs[i];
-          const url = doc.metadata.url;
-          if (!url || typeof url !== "string" || !url.trim()) {
-            throw new StoreError("Document metadata must include a valid URL");
-          }
-          const result = this.statements.insertDocument.run(
-            library.toLowerCase(),
-            version.toLowerCase(),
-            url,
-            doc.pageContent,
-            JSON.stringify(doc.metadata),
-            i,
-            (/* @__PURE__ */ new Date()).toISOString()
-            // Pass current timestamp for indexed_at
-          );
-          const rowId = result.lastInsertRowid;
-          this.statements.insertEmbedding.run(
-            BigInt(rowId),
-            library.toLowerCase(),
-            version.toLowerCase(),
-            JSON.stringify(paddedEmbeddings[i])
-          );
-        }
-      });
-      transaction(documents);
-    } catch (error) {
-      throw new ConnectionError("Failed to add documents to store", error);
-    }
-  }
-  /**
-   * Removes documents matching specified library and version
-   * @returns Number of documents deleted
-   */
-  async deleteDocuments(library, version) {
-    try {
-      const result = this.statements.deleteDocuments.run(
-        library.toLowerCase(),
-        version.toLowerCase()
-      );
-      return result.changes;
-    } catch (error) {
-      throw new ConnectionError("Failed to delete documents", error);
-    }
-  }
-  /**
-   * Retrieves a document by its ID.
-   * @param id The ID of the document.
-   * @returns The document, or null if not found.
-   */
-  async getById(id) {
-    try {
-      const row = this.statements.getById.get(id);
-      if (!row) {
-        return null;
-      }
-      return mapDbDocumentToDocument(row);
-    } catch (error) {
-      throw new ConnectionError(`Failed to get document by ID ${id}`, error);
-    }
-  }
-  /**
-   * Finds documents matching a text query using hybrid search.
-   * Combines vector similarity search with full-text search using Reciprocal Rank Fusion.
-   */
-  async findByContent(library, version, query, limit) {
-    try {
-      const rawEmbedding = await this.embeddings.embedQuery(query);
-      const embedding = this.padVector(rawEmbedding);
-      const ftsQuery = this.escapeFtsQuery(query);
-      const stmt = this.db.prepare(`
-        WITH vec_scores AS (
-          SELECT
-            rowid as id,
-            distance as vec_score
-          FROM documents_vec
-          WHERE library = ?
-            AND version = ?
-            AND embedding MATCH ?
-          ORDER BY vec_score
-          LIMIT ?
-        ),
-        fts_scores AS (
-          SELECT
-            f.rowid as id,
-            bm25(documents_fts, 10.0, 1.0, 5.0, 1.0) as fts_score
-          FROM documents_fts f
-          JOIN documents d ON f.rowid = d.rowid
-          WHERE d.library = ?
-            AND d.version = ?
-            AND documents_fts MATCH ?
-          ORDER BY fts_score
-          LIMIT ?
-        )
-        SELECT
-          d.id,
-          d.content,
-          d.metadata,
-          COALESCE(1 / (1 + v.vec_score), 0) as vec_score,
-          COALESCE(1 / (1 + f.fts_score), 0) as fts_score
-        FROM documents d
-        LEFT JOIN vec_scores v ON d.id = v.id
-        LEFT JOIN fts_scores f ON d.id = f.id
-        WHERE v.id IS NOT NULL OR f.id IS NOT NULL
-      `);
-      const rawResults = stmt.all(
-        library.toLowerCase(),
-        version.toLowerCase(),
-        JSON.stringify(embedding),
-        limit,
-        library.toLowerCase(),
-        version.toLowerCase(),
-        ftsQuery,
-        // Use the escaped query
-        limit
-      );
-      const rankedResults = this.assignRanks(rawResults);
-      const topResults = rankedResults.sort((a, b) => b.rrf_score - a.rrf_score).slice(0, limit);
-      return topResults.map((row) => ({
-        ...mapDbDocumentToDocument(row),
-        metadata: {
-          ...JSON.parse(row.metadata),
-          score: row.rrf_score,
-          vec_rank: row.vec_rank,
-          fts_rank: row.fts_rank
-        }
-      }));
-    } catch (error) {
-      throw new ConnectionError(
-        `Failed to find documents by content with query "${query}"`,
-        error
-      );
-    }
-  }
-  /**
-   * Finds child chunks of a given document based on path hierarchy.
-   */
-  async findChildChunks(library, version, id, limit) {
-    try {
-      const parent = await this.getById(id);
-      if (!parent) {
-        return [];
-      }
-      const parentPath = parent.metadata.path ?? [];
-      const parentUrl = parent.metadata.url;
-      const result = this.statements.getChildChunks.all(
-        library.toLowerCase(),
-        version.toLowerCase(),
-        parentUrl,
-        parentPath.length + 1,
-        JSON.stringify(parentPath),
-        id,
-        limit
-      );
-      return result.map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError(`Failed to find child chunks for ID ${id}`, error);
-    }
-  }
-  /**
-   * Finds preceding sibling chunks of a given document.
-   */
-  async findPrecedingSiblingChunks(library, version, id, limit) {
-    try {
-      const reference = await this.getById(id);
-      if (!reference) {
-        return [];
-      }
-      const refMetadata = reference.metadata;
-      const result = this.statements.getPrecedingSiblings.all(
-        library.toLowerCase(),
-        version.toLowerCase(),
-        refMetadata.url,
-        id,
-        JSON.stringify(refMetadata.path),
-        limit
-      );
-      return result.reverse().map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError(
-        `Failed to find preceding sibling chunks for ID ${id}`,
-        error
-      );
-    }
-  }
-  /**
-   * Finds subsequent sibling chunks of a given document.
-   */
-  async findSubsequentSiblingChunks(library, version, id, limit) {
-    try {
-      const reference = await this.getById(id);
-      if (!reference) {
-        return [];
-      }
-      const refMetadata = reference.metadata;
-      const result = this.statements.getSubsequentSiblings.all(
-        library.toLowerCase(),
-        version.toLowerCase(),
-        refMetadata.url,
-        id,
-        JSON.stringify(refMetadata.path),
-        limit
-      );
-      return result.map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError(
-        `Failed to find subsequent sibling chunks for ID ${id}`,
-        error
-      );
-    }
-  }
-  /**
-   * Finds the parent chunk of a given document.
-   */
-  async findParentChunk(library, version, id) {
-    try {
-      const child = await this.getById(id);
-      if (!child) {
-        return null;
-      }
-      const childMetadata = child.metadata;
-      const path2 = childMetadata.path ?? [];
-      const parentPath = path2.slice(0, -1);
-      if (parentPath.length === 0) {
-        return null;
-      }
-      const result = this.statements.getParentChunk.get(
-        library.toLowerCase(),
-        version.toLowerCase(),
-        childMetadata.url,
-        JSON.stringify(parentPath),
-        id
-      );
-      if (!result) {
-        return null;
-      }
-      return mapDbDocumentToDocument(result);
-    } catch (error) {
-      throw new ConnectionError(`Failed to find parent chunk for ID ${id}`, error);
-    }
-  }
-  /**
-   * Fetches multiple documents by their IDs in a single call.
-   * Returns an array of Document objects, sorted by their sort_order.
-   */
-  async findChunksByIds(library, version, ids) {
-    if (!ids.length) return [];
-    try {
-      const placeholders = ids.map(() => "?").join(",");
-      const stmt = this.db.prepare(
-        `SELECT * FROM documents WHERE library = ? AND version = ? AND id IN (${placeholders}) ORDER BY sort_order`
-      );
-      const rows = stmt.all(
-        library.toLowerCase(),
-        version.toLowerCase(),
-        ...ids
-      );
-      return rows.map((row) => mapDbDocumentToDocument(row));
-    } catch (error) {
-      throw new ConnectionError("Failed to fetch documents by IDs", error);
-    }
-  }
-}
-class DocumentManagementService {
-  store;
-  documentRetriever;
-  splitter;
-  /**
-   * Normalizes a version string, converting null or undefined to an empty string
-   * and converting to lowercase.
-   */
-  normalizeVersion(version) {
-    return (version ?? "").toLowerCase();
-  }
-  constructor() {
-    let dbPath;
-    let dbDir;
-    const envStorePath = process.env.DOCS_MCP_STORE_PATH;
-    if (envStorePath) {
-      dbDir = envStorePath;
-      dbPath = path.join(dbDir, "documents.db");
-      logger.debug(`💾 Using database directory from DOCS_MCP_STORE_PATH: ${dbDir}`);
-    } else {
-      const projectRoot2 = getProjectRoot();
-      const oldDbDir = path.join(projectRoot2, ".store");
-      const oldDbPath = path.join(oldDbDir, "documents.db");
-      const oldDbExists = fs$1.existsSync(oldDbPath);
-      if (oldDbExists) {
-        dbPath = oldDbPath;
-        dbDir = oldDbDir;
-        logger.debug(`💾 Using legacy database path: ${dbPath}`);
-      } else {
-        const standardPaths = envPaths("docs-mcp-server", { suffix: "" });
-        dbDir = standardPaths.data;
-        dbPath = path.join(dbDir, "documents.db");
-        logger.debug(`💾 Using standard database directory: ${dbDir}`);
-      }
-    }
-    try {
-      fs$1.mkdirSync(dbDir, { recursive: true });
-    } catch (error) {
-      logger.error(`⚠️ Failed to create database directory ${dbDir}: ${error}`);
-    }
-    this.store = new DocumentStore(dbPath);
-    this.documentRetriever = new DocumentRetrieverService(this.store);
-    const semanticSplitter = new SemanticMarkdownSplitter(
-      SPLITTER_PREFERRED_CHUNK_SIZE,
-      SPLITTER_MAX_CHUNK_SIZE
-    );
-    const greedySplitter = new GreedySplitter(
-      semanticSplitter,
-      SPLITTER_MIN_CHUNK_SIZE,
-      SPLITTER_PREFERRED_CHUNK_SIZE
-    );
-    this.splitter = greedySplitter;
-  }
-  /**
-   * Initializes the underlying document store.
-   */
-  async initialize() {
-    await this.store.initialize();
-  }
-  /**
-   * Shuts down the underlying document store.
-   */
-  async shutdown() {
-    logger.info("🔌 Shutting down store manager");
-    await this.store.shutdown();
-  }
-  /**
-   * Validates if a library exists in the store (either versioned or unversioned).
-   * Throws LibraryNotFoundError with suggestions if the library is not found.
-   * @param library The name of the library to validate.
-   * @throws {LibraryNotFoundError} If the library does not exist.
-   */
-  async validateLibraryExists(library) {
-    logger.info(`🔎 Validating existence of library: ${library}`);
-    const normalizedLibrary = library.toLowerCase();
-    const versions = await this.listVersions(normalizedLibrary);
-    const hasUnversioned = await this.exists(normalizedLibrary, "");
-    if (versions.length === 0 && !hasUnversioned) {
-      logger.warn(`⚠️ Library '${library}' not found.`);
-      const allLibraries = await this.listLibraries();
-      const libraryNames = allLibraries.map((lib) => lib.library);
-      let suggestions = [];
-      if (libraryNames.length > 0) {
-        const fuse = new Fuse(libraryNames, {
-          // Configure fuse.js options if needed (e.g., threshold)
-          // isCaseSensitive: false, // Handled by normalizing library names
-          // includeScore: true,
-          threshold: 0.4
-          // Adjust threshold for desired fuzziness (0=exact, 1=match anything)
-        });
-        const results = fuse.search(normalizedLibrary);
-        suggestions = results.slice(0, 3).map((result) => result.item);
-        logger.info(`🔍 Found suggestions: ${suggestions.join(", ")}`);
-      }
-      throw new LibraryNotFoundError(library, suggestions);
-    }
-    logger.info(`✅ Library '${library}' confirmed to exist.`);
-  }
-  /**
-   * Returns a list of all available semantic versions for a library.
-   */
-  async listVersions(library) {
-    const versions = await this.store.queryUniqueVersions(library);
-    return versions.filter((v) => semver__default.valid(v)).map((version) => ({ version }));
-  }
-  /**
-   * Checks if documents exist for a given library and optional version.
-   * If version is omitted, checks for documents without a specific version.
-   */
-  async exists(library, version) {
-    const normalizedVersion = this.normalizeVersion(version);
-    return this.store.checkDocumentExists(library, normalizedVersion);
-  }
-  /**
-   * Finds the most appropriate version of documentation based on the requested version.
-   * When no target version is specified, returns the latest version.
-   *
-   * Version matching behavior:
-   * - Exact versions (e.g., "18.0.0"): Matches that version or any earlier version
-   * - X-Range patterns (e.g., "5.x", "5.2.x"): Matches within the specified range
-   * - "latest" or no version: Returns the latest available version
-   *
-   * For documentation, we prefer matching older versions over no match at all,
-   * since older docs are often still relevant and useful.
-   * Also checks if unversioned documents exist for the library.
-   */
-  async findBestVersion(library, targetVersion) {
-    logger.info(
-      `🔍 Finding best version for ${library}${targetVersion ? `@${targetVersion}` : ""}`
-    );
-    const hasUnversioned = await this.store.checkDocumentExists(library, "");
-    const validSemverVersions = await this.listVersions(library);
-    if (validSemverVersions.length === 0) {
-      if (hasUnversioned) {
-        logger.info(`ℹ️ Unversioned documents exist for ${library}`);
-        return { bestMatch: null, hasUnversioned: true };
-      }
-      logger.warn(`⚠️ No valid versions found for ${library}`);
-      const allLibraryDetails = await this.store.queryLibraryVersions();
-      const libraryDetails = allLibraryDetails.get(library) ?? [];
-      throw new VersionNotFoundError(library, targetVersion ?? "", libraryDetails);
-    }
-    const versionStrings = validSemverVersions.map((v) => v.version);
-    let bestMatch = null;
-    if (!targetVersion || targetVersion === "latest") {
-      bestMatch = semver__default.maxSatisfying(versionStrings, "*");
-    } else {
-      const versionRegex = /^(\d+)(?:\.(?:x(?:\.x)?|\d+(?:\.(?:x|\d+))?))?$|^$/;
-      if (!versionRegex.test(targetVersion)) {
-        logger.warn(`⚠️ Invalid target version format: ${targetVersion}`);
-      } else {
-        let range = targetVersion;
-        if (!semver__default.validRange(targetVersion)) {
-          range = `~${targetVersion}`;
-        } else if (semver__default.valid(targetVersion)) {
-          range = `${range} || <=${targetVersion}`;
-        }
-        bestMatch = semver__default.maxSatisfying(versionStrings, range);
-      }
-    }
-    if (bestMatch) {
-      logger.info(
-        `✅ Found best match version ${bestMatch} for ${library}@${targetVersion}`
-      );
-    } else {
-      logger.warn(`⚠️ No matching semver version found for ${library}@${targetVersion}`);
-    }
-    if (!bestMatch && !hasUnversioned) {
-      const allLibraryDetails = await this.store.queryLibraryVersions();
-      const libraryDetails = allLibraryDetails.get(library) ?? [];
-      throw new VersionNotFoundError(library, targetVersion ?? "", libraryDetails);
-    }
-    return { bestMatch, hasUnversioned };
-  }
-  /**
-   * Removes all documents for a specific library and optional version.
-   * If version is omitted, removes documents without a specific version.
-   */
-  async removeAllDocuments(library, version) {
-    const normalizedVersion = this.normalizeVersion(version);
-    logger.info(
-      `🗑️ Removing all documents from ${library}@${normalizedVersion || "[no version]"} store`
-    );
-    const count = await this.store.deleteDocuments(library, normalizedVersion);
-    logger.info(`📊 Deleted ${count} documents`);
-  }
-  /**
-   * Adds a document to the store, splitting it into smaller chunks for better search results.
-   * Uses SemanticMarkdownSplitter to maintain markdown structure and content types during splitting.
-   * Preserves hierarchical structure of documents and distinguishes between text and code segments.
-   * If version is omitted, the document is added without a specific version.
-   */
-  async addDocument(library, version, document) {
-    const normalizedVersion = this.normalizeVersion(version);
-    const url = document.metadata.url;
-    if (!url || typeof url !== "string" || !url.trim()) {
-      throw new StoreError("Document metadata must include a valid URL");
-    }
-    logger.info(`📚 Adding document: ${document.metadata.title}`);
-    if (!document.pageContent.trim()) {
-      throw new Error("Document content cannot be empty");
-    }
-    const chunks = await this.splitter.splitText(document.pageContent);
-    const splitDocs = chunks.map((chunk) => ({
-      pageContent: chunk.content,
-      metadata: {
-        ...document.metadata,
-        level: chunk.section.level,
-        path: chunk.section.path
-      }
-    }));
-    logger.info(`📄 Split document into ${splitDocs.length} chunks`);
-    await this.store.addDocuments(library, normalizedVersion, splitDocs);
-  }
-  /**
-   * Searches for documentation content across versions.
-   * Uses hybrid search (vector + FTS).
-   * If version is omitted, searches documents without a specific version.
-   */
-  async searchStore(library, version, query, limit = 5) {
-    const normalizedVersion = this.normalizeVersion(version);
-    return this.documentRetriever.search(library, normalizedVersion, query, limit);
-  }
-  async listLibraries() {
-    const libraryMap = await this.store.queryLibraryVersions();
-    return Array.from(libraryMap.entries()).map(([library, versions]) => ({
-      library,
-      versions
-      // The versions array already contains LibraryVersionDetails
-    }));
-  }
-}
-export {
-  DocumentManagementService as D,
-  FileFetcher as F,
-  HttpFetcher as H,
-  LibraryNotFoundError as L,
-  MarkdownPipeline as M,
-  PipelineJobStatus as P,
-  SearchTool as S,
-  ToolError as T,
-  VersionNotFoundError as V,
-  PipelineManager as a,
-  DEFAULT_MAX_DEPTH$1 as b,
-  DEFAULT_MAX_PAGES$1 as c,
-  LogLevel as d,
-  ScrapeTool as e,
-  ListLibrariesTool as f,
-  DEFAULT_PROTOCOL as g,
-  DEFAULT_HTTP_PORT as h,
-  DEFAULT_MAX_CONCURRENCY as i,
-  ScrapeMode as j,
-  HtmlPipeline as k,
-  logger as l,
-  ScraperError as m,
-  createJSDOM as n,
-  getProjectRoot as o,
-  DEFAULT_WEB_PORT as p,
-  DimensionError as q,
-  VECTOR_DIMENSION as r,
-  setLogLevel as s
-};
-//# sourceMappingURL=DocumentManagementService-BGW9iWNn.js.map