docmunch 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,1619 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mcp/loader.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
+import matter2 from "gray-matter";
+function loadDocs(docsDir) {
+  const sources = [];
+  const pages = [];
+  let rootManifest;
+  try {
+    const raw = readFileSync3(join6(docsDir, "manifest.json"), "utf-8");
+    rootManifest = JSON.parse(raw);
+  } catch {
+    return { sources: [], pages: [] };
+  }
+  for (const sourceEntry of rootManifest.sources) {
+    const sourceDir = join6(docsDir, sourceEntry.path);
+    let sourceManifest;
+    try {
+      const raw = readFileSync3(join6(sourceDir, "_index.json"), "utf-8");
+      sourceManifest = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    let pageCount = 0;
+    for (const pageEntry of sourceManifest.pages) {
+      try {
+        const raw = readFileSync3(join6(sourceDir, pageEntry.path), "utf-8");
+        const parsed = matter2(raw);
+        pages.push({
+          source: sourceManifest.name,
+          path: pageEntry.path,
+          title: pageEntry.title,
+          url: String(parsed.data.source || ""),
+          platform: String(parsed.data.platform || sourceManifest.platform),
+          fetchedAt: String(parsed.data.fetched_at || sourceManifest.fetched_at),
+          content: parsed.content.trim()
+        });
+        pageCount++;
+      } catch {
+        continue;
+      }
+    }
+    const loadedSource = {
+      name: sourceManifest.name,
+      url: sourceManifest.url,
+      platform: sourceManifest.platform,
+      fetchedAt: sourceManifest.fetched_at,
+      pageCount
+    };
+    if (sourceManifest.display_name) loadedSource.displayName = sourceManifest.display_name;
+    if (sourceManifest.description) loadedSource.description = sourceManifest.description;
+    if (sourceManifest.icon_url !== void 0) loadedSource.iconUrl = sourceManifest.icon_url;
+    sources.push(loadedSource);
+  }
+  return { sources, pages };
+}
+var init_loader = __esm({
+  "src/mcp/loader.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/search.ts
+import MiniSearch from "minisearch";
+function buildSearchIndex(pages) {
+  const miniSearch = new MiniSearch({
+    fields: ["title", "content"],
+    storeFields: ["source", "path", "title", "url"],
+    idField: "id"
+  });
+  const documents = pages.map((page, i) => ({
+    id: String(i),
+    ...page
+  }));
+  miniSearch.addAll(documents);
+  return {
+    search(query, options) {
+      if (!query.trim()) return [];
+      const filter = options?.source ? (result) => result.source === options.source : void 0;
+      const results = miniSearch.search(query, {
+        prefix: true,
+        fuzzy: 0.2,
+        filter
+      });
+      const limit = options?.limit ?? 10;
+      return results.slice(0, limit).map((r) => ({
+        source: r.source,
+        path: r.path,
+        title: r.title,
+        url: r.url,
+        score: r.score
+      }));
+    }
+  };
+}
+var init_search = __esm({
+  "src/mcp/search.ts"() {
+    "use strict";
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createMcpServer: () => createMcpServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+function createMcpServer(docsDir) {
+  const docs = loadDocs(docsDir);
+  const searchIndex = buildSearchIndex(docs.pages);
+  const server = new McpServer({
+    name: "doc2ctx",
+    version: "0.1.0"
+  });
+  server.tool(
+    "list_sources",
+    "List all documentation sources available in the docs directory",
+    {},
+    async () => {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              docs.sources.map((s) => ({
+                name: s.name,
+                url: s.url,
+                platform: s.platform,
+                fetchedAt: s.fetchedAt,
+                pageCount: s.pageCount,
+                ...s.displayName && { displayName: s.displayName },
+                ...s.description && { description: s.description },
+                ...s.iconUrl !== void 0 && { iconUrl: s.iconUrl }
+              })),
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_pages",
+    "List all pages for a specific documentation source",
+    { source: z.string().describe("Name of the documentation source") },
+    async ({ source }) => {
+      const sourceEntry = docs.sources.find((s) => s.name === source);
+      if (!sourceEntry) {
+        return {
+          content: [{ type: "text", text: `Source "${source}" not found. Use list_sources to see available sources.` }],
+          isError: true
+        };
+      }
+      const pages = docs.pages.filter((p) => p.source === source).map((p) => ({ title: p.title, path: p.path }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(pages, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "read_page",
+    "Read the full markdown content of a documentation page",
+    {
+      source: z.string().describe("Name of the documentation source"),
+      path: z.string().describe("Path of the page within the source (from list_pages)")
+    },
+    async ({ source, path }) => {
+      const page = docs.pages.find((p) => p.source === source && p.path === path);
+      if (!page) {
+        return {
+          content: [{ type: "text", text: `Page "${path}" not found in source "${source}". Use list_pages to see available pages.` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: page.content }]
+      };
+    }
+  );
+  server.tool(
+    "search_docs",
+    "Search across all documentation pages by keyword",
+    {
+      query: z.string().describe("Search query"),
+      source: z.string().optional().describe("Filter results to a specific source"),
+      limit: z.number().optional().describe("Maximum number of results (default 10)")
+    },
+    async ({ query, source, limit }) => {
+      if (!query.trim()) {
+        return {
+          content: [{ type: "text", text: "Search query cannot be empty." }],
+          isError: true
+        };
+      }
+      const results = searchIndex.search(query, { source, limit });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              results.map((r) => ({
+                source: r.source,
+                path: r.path,
+                title: r.title,
+                score: r.score
+              })),
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_loader();
+    init_search();
+  }
+});
+
+// src/cli.ts
+import { defineCommand as defineCommand6, runMain, runCommand } from "citty";
+import consola6 from "consola";
+
+// src/commands/fetch.ts
+import { defineCommand } from "citty";
+import { dirname as dirname3 } from "path";
+import consola2 from "consola";
+import * as cheerio6 from "cheerio";
+
+// src/pipeline/fetcher.ts
+import { ofetch } from "ofetch";
+import { execSync } from "child_process";
+import consola from "consola";
+var BROWSER_RETRY_CODES = /* @__PURE__ */ new Set([403, 406, 429]);
+var CHALLENGE_PATTERNS = [
+  "verify you are human",
+  "just a moment",
+  "checking your browser",
+  "attention required",
+  "enable javascript and cookies"
+];
+function isChallengeContent(html) {
+  const lower = html.toLowerCase();
+  return CHALLENGE_PATTERNS.some((p) => lower.includes(p));
+}
+async function fetchPage(url) {
+  try {
+    return await ofetch(url, { responseType: "text" });
+  } catch (err) {
+    const status = err?.response?.status ?? err?.statusCode;
+    if (status && BROWSER_RETRY_CODES.has(status)) {
+      consola.warn(
+        `Static fetch returned ${status}, retrying with browser...`
+      );
+      return fetchWithBrowser(url);
+    }
+    throw err;
+  }
+}
+async function fetchWithBrowser(url) {
+  const playwright = await loadPlaywright();
+  let html = await launchAndFetch(playwright, url, true);
+  if (isChallengeContent(html)) {
+    consola.warn("Bot protection detected, retrying with visible browser...");
+    html = await launchAndFetch(playwright, url, false);
+  }
+  return html;
+}
+async function loadPlaywright() {
+  try {
+    return await import("playwright");
+  } catch {
+    consola.info(
+      "This site requires a browser to fetch. Installing Playwright..."
+    );
+    try {
+      execSync("npm install -g playwright", { stdio: "inherit" });
+      execSync("npx playwright install chromium", { stdio: "inherit" });
+      return await import("playwright");
+    } catch {
+      const err = new Error(
+        "Failed to auto-install Playwright. Install it manually:\n\n  npm install -g playwright && npx playwright install chromium\n"
+      );
+      err.code = "ERR_PLAYWRIGHT_NOT_INSTALLED";
+      throw err;
+    }
+  }
+}
+async function launchAndFetch(playwright, url, headless) {
+  const browser = await playwright.chromium.launch({ headless });
+  try {
+    const page = await browser.newPage();
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    await page.waitForTimeout(2e3);
+    return await page.content();
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/pipeline/extractor.ts
+import * as cheerio3 from "cheerio";
+import { Readability } from "@mozilla/readability";
+import { parseHTML } from "linkedom";
+
+// src/platforms/mintlify.ts
+import * as cheerio from "cheerio";
+var mintlify = {
+  id: "mintlify",
+  detect(url, $) {
+    if ($('meta[name="generator"][content*="Mintlify"]').length > 0) return true;
+    if ($("script[src*='mintlify']").length > 0) return true;
+    if ($("[data-mintlify]").length > 0) return true;
+    return false;
+  },
+  contentSelector() {
+    return "article, main";
+  },
+  removeSelectors() {
+    return [
+      "nav",
+      "header",
+      "footer",
+      "[role='navigation']",
+      ".sidebar",
+      "[class*='sidebar']",
+      "[class*='cookie']",
+      "[class*='banner']",
+      "script",
+      "style"
+    ];
+  },
+  navLinkSelector() {
+    return "nav a[href], .sidebar a[href], [class*='sidebar'] a[href]";
+  },
+  discoverUrls(html, baseUrl) {
+    const $ = cheerio.load(html);
+    const paths = /* @__PURE__ */ new Set();
+    $("script").each((_, el) => {
+      const text = $(el).html() || "";
+      const escaped = /\\?"href\\?"\s*:\s*\\?"(\/[a-z0-9][a-z0-9\/-]*)\\?"/g;
+      let match = escaped.exec(text);
+      while (match !== null) {
+        paths.add(match[1]);
+        match = escaped.exec(text);
+      }
+    });
+    const origin = new URL(baseUrl).origin;
+    const basePath = new URL(baseUrl).pathname.split("/").slice(0, 2).join("/");
+    return [...paths].map((p) => {
+      if (p.startsWith(basePath)) {
+        return origin + p;
+      }
+      return origin + basePath + p;
+    });
+  }
+};
+
+// src/platforms/docusaurus.ts
+var docusaurus = {
+  id: "docusaurus",
+  detect(url, $) {
+    if ($('meta[name="generator"][content*="Docusaurus"]').length > 0)
+      return true;
+    if ($(".theme-doc-sidebar-container").length > 0) return true;
+    if ($('meta[name="docusaurus_locale"]').length > 0) return true;
+    return false;
+  },
+  contentSelector() {
+    return "article, [role='main'], .theme-doc-markdown";
+  },
+  removeSelectors() {
+    return [
+      ".navbar",
+      "footer",
+      ".theme-doc-toc-desktop",
+      ".theme-doc-sidebar-container",
+      ".pagination-nav",
+      ".theme-doc-breadcrumbs",
+      "nav",
+      "script",
+      "style"
+    ];
+  },
+  navLinkSelector() {
+    return ".menu__link[href]";
+  }
+};
+
+// src/platforms/readme.ts
+var readme = {
+  id: "readme",
+  detect(url, $) {
+    let rmClassCount = 0;
+    $("[class]").each((_, el) => {
+      const cls = $(el).attr("class") || "";
+      if (/\brm-/.test(cls)) rmClassCount++;
+    });
+    if (rmClassCount > 2) return true;
+    if ($(".rm-Article").length > 0) return true;
+    if ($(".rm-Markdown").length > 0) return true;
+    return false;
+  },
+  contentSelector() {
+    return ".markdown-body, .rm-Article, .rm-Markdown";
+  },
+  removeSelectors() {
+    return [
+      "nav",
+      "header",
+      "footer",
+      ".rm-Sidebar",
+      ".rm-TableOfContents",
+      "[class*='cookie']",
+      "script",
+      "style"
+    ];
+  },
+  navLinkSelector() {
+    return ".rm-Sidebar a[href]";
+  }
+};
+
+// src/platforms/gitbook.ts
+var gitbook = {
+  id: "gitbook",
+  detect(url, $) {
+    if ($('meta[name="generator"][content*="GitBook"]').length > 0) return true;
+    try {
+      const parsed = new URL(url);
+      if (parsed.hostname.endsWith(".gitbook.io")) return true;
+    } catch {
+    }
+    if ($('[data-testid="page.contentEditor"]').length > 0) return true;
+    return false;
+  },
+  contentSelector() {
+    return '[data-testid="page.contentEditor"], main, article';
+  },
+  removeSelectors() {
+    return [
+      "nav",
+      "header",
+      "footer",
+      "[class*='sidebar']",
+      "[class*='toc']",
+      "[class*='cookie']",
+      "script",
+      "style"
+    ];
+  },
+  navLinkSelector() {
+    return "nav a[href], aside a[href]";
+  }
+};
+
+// src/platforms/generic.ts
+import * as cheerio2 from "cheerio";
+var SIDEBAR_SELECTORS = [
+  "aside nav a[href]",
+  "aside a[href]",
+  '[class*="sidebar"] a[href]',
+  '[class*="side-bar"] a[href]',
+  '[role="complementary"] a[href]',
+  '[class*="toc"] a[href]',
+  '[class*="table-of-contents"] a[href]'
+];
+var MIN_SIDEBAR_LINKS = 3;
+function resolveLinks($, selector, baseUrl, scope) {
+  const links = [];
+  const els = scope ? scope.find(selector) : $(selector);
+  els.each((_, el) => {
+    const href = $(el).attr("href");
+    if (!href || href.startsWith("#") || href.startsWith("mailto:")) return;
+    try {
+      links.push(new URL(href, baseUrl).href);
+    } catch {
+    }
+  });
+  return [...new Set(links)];
+}
+var generic = {
+  id: "generic",
+  detect(_url, _$) {
+    return true;
+  },
+  contentSelector() {
+    return "article, main, [role='main'], .content";
+  },
+  removeSelectors() {
+    return [
+      "nav",
+      "header",
+      "footer",
+      "[role='navigation']",
+      "[class*='sidebar']",
+      "[class*='cookie']",
+      "[class*='banner']",
+      "script",
+      "style",
+      "noscript"
+    ];
+  },
+  navLinkSelector() {
+    return null;
+  },
+  discoverUrls(html, baseUrl) {
+    const $ = cheerio2.load(html);
+    for (const selector of SIDEBAR_SELECTORS) {
+      const links = resolveLinks($, selector, baseUrl);
+      if (links.length >= MIN_SIDEBAR_LINKS) {
+        return links;
+      }
+    }
+    return [];
+  }
+};
+
+// src/platforms/registry.ts
+var platformStrategies = [
+  mintlify,
+  docusaurus,
+  readme,
+  gitbook,
+  generic
+];
+function getStrategy(id) {
+  const strategy = platformStrategies.find((s) => s.id === id);
+  if (!strategy) {
+    throw new Error(`Unknown platform: ${id}`);
+  }
+  return strategy;
+}
+
+// src/pipeline/resolver.ts
+function resolve(url, $) {
+  for (const strategy of platformStrategies) {
+    if (strategy.detect(url, $)) {
+      return strategy.id;
+    }
+  }
+  return "generic";
+}
+
+// src/pipeline/extractor.ts
+function extract(html, url) {
+  const $ = cheerio3.load(html);
+  const platform = resolve(url, $);
+  const strategy = getStrategy(platform);
+  const title = extractTitle($);
+  if (platform !== "generic") {
+    for (const sel of strategy.removeSelectors()) {
+      $(sel).remove();
+    }
+    const contentEl = $(strategy.contentSelector()).first();
+    const selectorContent = contentEl.html();
+    if (selectorContent && selectorContent.trim().length >= 100) {
+      return { content: selectorContent, title, platform };
+    }
+  }
+  let article = null;
+  try {
+    const { document } = parseHTML(html);
+    const reader = new Readability(document);
+    article = reader.parse();
+  } catch {
+  }
+  const content = article?.content || $("body").html() || html;
+  return {
+    content,
+    title: title || article?.title || "",
+    platform
+  };
+}
+function extractTitle($) {
+  const h1 = $("h1").first().text().trim();
+  if (h1) return h1;
+  const ogTitle = $('meta[property="og:title"]').attr("content")?.trim();
+  if (ogTitle) return ogTitle;
+  return $("title").text().trim();
+}
+
+// src/pipeline/transformer.ts
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+function transform(html) {
+  const td = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-"
+  });
+  td.use(gfm);
+  addCalloutRule(td);
+  addTabbedContentRule(td);
+  addCodeBlockLangRule(td);
+  addHiddenElementRule(td);
+  return td.turndown(html);
+}
+function isElement(node) {
+  return node.nodeType === 1;
+}
+function getAttr(node, attr) {
+  if (isElement(node)) {
+    return node.getAttribute(attr) || "";
+  }
+  return "";
+}
+function getTagName(node) {
+  if (isElement(node)) {
+    return node.tagName.toLowerCase();
+  }
+  return "";
+}
+function addCalloutRule(td) {
+  td.addRule("callouts", {
+    filter(node) {
+      if (!isElement(node)) return false;
+      const tag = getTagName(node);
+      if (tag === "aside") return true;
+      const cls = getAttr(node, "class");
+      if (/\b(admonition|callout|alert|notice|warning|info|tip|note|caution|danger)\b/i.test(
+        cls
+      ))
+        return true;
+      if (getAttr(node, "role") === "alert") return true;
+      return false;
+    },
+    replacement(content, node) {
+      const cls = getAttr(node, "class").toLowerCase();
+      let type = "Note";
+      if (/warning|caution/.test(cls)) type = "Warning";
+      else if (/danger|error/.test(cls)) type = "Danger";
+      else if (/tip|success/.test(cls)) type = "Tip";
+      else if (/info/.test(cls)) type = "Info";
+      const lines = content.trim().split("\n");
+      const quoted = lines.map((line) => `> ${line}`).join("\n");
+      return `
+> **${type}**
+${quoted}
+
+`;
+    }
+  });
+}
+function addTabbedContentRule(td) {
+  td.addRule("tabbed-content", {
+    filter(node) {
+      if (!isElement(node)) return false;
+      const cls = getAttr(node, "class");
+      if (/\b(tab-panel|tabpanel|tabs__item)\b/i.test(cls)) return true;
+      if (getAttr(node, "role") === "tabpanel") return true;
+      return false;
+    },
+    replacement(content, node) {
+      const label = getAttr(node, "aria-label") || getAttr(node, "data-label") || getAttr(node, "data-value") || "";
+      if (label) {
+        return `
+**${label}**
+
+${content.trim()}
+
+`;
+      }
+      return `
+${content.trim()}
+
+`;
+    }
+  });
+}
+function addCodeBlockLangRule(td) {
+  td.addRule("code-block-lang", {
+    filter(node) {
+      if (!isElement(node)) return false;
+      if (getTagName(node) !== "pre") return false;
+      const codeEl = node.querySelector("code");
+      if (!codeEl) return false;
+      const lang = getAttr(node, "data-language") || getAttr(node, "data-lang") || (codeEl.getAttribute("data-language") || "") || (codeEl.getAttribute("data-lang") || "");
+      return lang.length > 0;
+    },
+    replacement(_content, node) {
+      if (!isElement(node)) return _content;
+      const codeEl = node.querySelector("code");
+      const lang = getAttr(node, "data-language") || getAttr(node, "data-lang") || (codeEl.getAttribute("data-language") || "") || (codeEl.getAttribute("data-lang") || "");
+      const code = codeEl.textContent || "";
+      return `
+\`\`\`${lang}
+${code}
+\`\`\`
+`;
+    }
+  });
+}
+function addHiddenElementRule(td) {
+  td.addRule("hidden-elements", {
+    filter(node) {
+      if (!isElement(node)) return false;
+      const style = getAttr(node, "style");
+      if (!/display\s*:\s*none/i.test(style)) return false;
+      const cls = getAttr(node, "class");
+      if (/\b(tab-panel|tabpanel)\b/i.test(cls)) return false;
+      if (getAttr(node, "role") === "tabpanel") return false;
+      return true;
+    },
+    replacement() {
+      return "";
+    }
+  });
+}
+
+// src/pipeline/writer.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import matter from "gray-matter";
+
+// src/utils/slug.ts
+function filePathForPage(pageUrl, basePrefix) {
+  const parsed = new URL(pageUrl);
+  let pathname = parsed.pathname.replace(/\/+$/, "");
+  const normalizedPrefix = basePrefix.replace(/\/+$/, "");
+  if (pathname.startsWith(normalizedPrefix)) {
+    pathname = pathname.slice(normalizedPrefix.length);
+  }
+  pathname = pathname.replace(/^\/+/, "");
+  if (!pathname) return "index.md";
+  return pathname + ".md";
+}
+
+// src/pipeline/writer.ts
+function write(markdown, outputPath, options) {
+  const content = matter.stringify(markdown, {
+    source: options.sourceUrl,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: options.platform,
+    title: options.title,
+    docs2ai_version: "0.1.0"
+  });
+  if (outputPath) {
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, content, "utf-8");
+  } else {
+    process.stdout.write(content);
+  }
+}
+function writePage(markdown, filePath, options) {
+  const content = matter.stringify(markdown, {
+    source: options.sourceUrl,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    platform: options.platform,
+    title: options.title,
+    docs2ai_version: "0.1.0"
+  });
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content, "utf-8");
+}
+function writePages(pages, outputDir, basePrefix) {
+  const usedPaths = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const page of pages) {
+    let relPath = filePathForPage(page.url, basePrefix);
+    if (usedPaths.has(relPath)) {
+      const base = relPath.replace(/\.md$/, "");
+      let i = 2;
+      while (usedPaths.has(`${base}-${i}.md`)) i++;
+      relPath = `${base}-${i}.md`;
+    }
+    usedPaths.add(relPath);
+    const filePath = join(outputDir, relPath);
+    writePage(page.markdown, filePath, {
+      sourceUrl: page.url,
+      title: page.title,
+      platform: page.platform
+    });
+    entries.push({ title: page.title, path: relPath });
+  }
+  return entries;
+}
+
+// src/crawl/crawler.ts
+import * as cheerio4 from "cheerio";
+import * as readline from "readline";
+
+// src/utils/url.ts
+function normalizeUrl(url) {
+  const parsed = new URL(url);
+  parsed.hash = "";
+  parsed.search = "";
+  return parsed.href.replace(/\/$/, "");
+}
+function slugFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname.replace(/\./g, "-").replace(/^www-/, "");
+  } catch {
+    return "source";
+  }
+}
+
+// src/crawl/boundary.ts
+function getCrawlPrefix(url) {
+  const parsed = new URL(url);
+  const pathParts = parsed.pathname.split("/");
+  pathParts.pop();
+  const pathPrefix = pathParts.join("/") + "/";
+  return { origin: parsed.origin, pathPrefix };
+}
+function computeCommonPrefix(startUrl, navUrls) {
+  const startParts = new URL(startUrl).pathname.split("/").filter(Boolean);
+  const parts = [...startParts];
+  for (const url of navUrls) {
+    const urlParts = new URL(url).pathname.split("/").filter(Boolean);
+    let i = 0;
+    while (i < parts.length && i < urlParts.length && parts[i] === urlParts[i]) {
+      i++;
+    }
+    parts.length = i;
+  }
+  return "/" + (parts.length > 0 ? parts.join("/") + "/" : "");
+}
+function isInBounds(candidateUrl, origin, pathPrefix) {
+  try {
+    const parsed = new URL(candidateUrl);
+    return parsed.origin === origin && parsed.pathname.startsWith(pathPrefix);
+  } catch {
+    return false;
+  }
+}
+
+// src/crawl/crawler.ts
+async function crawl(startUrl, options) {
+  const { origin } = getCrawlPrefix(startUrl);
+  let { pathPrefix } = getCrawlPrefix(startUrl);
+  const visited = /* @__PURE__ */ new Set();
+  const results = [];
+  let isFirstPage = true;
+  let interrupted = false;
+  let saveOnInterrupt = false;
+  const onSigint = async () => {
+    if (interrupted) {
+      process.exit(1);
+    }
+    interrupted = true;
+    if (results.length === 0) {
+      process.exit(0);
+    }
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr
+    });
+    const answer = await new Promise((resolve3) => {
+      rl.question(
+        `
+Crawl interrupted. Save ${results.length} page(s) collected so far? (y/n) `,
+        resolve3
+      );
+    });
+    rl.close();
+    saveOnInterrupt = answer.trim().toLowerCase().startsWith("y");
+    if (!saveOnInterrupt) {
+      process.exit(0);
+    }
+  };
+  process.on("SIGINT", onSigint);
+  const queue = [[startUrl, 0]];
+  visited.add(normalizeUrl(startUrl));
+  try {
+    while (queue.length > 0 && !interrupted) {
+      const [url, depth] = queue.shift();
+      let html;
+      try {
+        html = await fetchPage(url);
+      } catch {
+        options.onPageFetched?.(url, results.length, results.length + queue.length);
+        continue;
+      }
+      results.push({ url, html });
+      options.onPageFetched?.(url, results.length, results.length + queue.length);
+      if (depth < options.maxDepth) {
+        if (isFirstPage) {
+          const hasNavScope = !!options.navLinkSelector;
+          if (hasNavScope) {
+            const allNavUrls = options.discoverUrls ? discoverSameOriginCustom(html, url, origin, options.discoverUrls) : discoverSameOrigin(html, url, origin, options.navLinkSelector);
+            if (allNavUrls.length > 0) {
+              pathPrefix = computeCommonPrefix(startUrl, allNavUrls);
+            }
+          }
+          isFirstPage = false;
+        }
+        const links = options.discoverUrls ? discoverLinksCustom(html, url, origin, pathPrefix, options.discoverUrls) : discoverLinks(html, url, origin, pathPrefix, options.navLinkSelector);
+        for (const link of links) {
+          const normalized = normalizeUrl(link);
+          if (!visited.has(normalized)) {
+            visited.add(normalized);
+            queue.push([link, depth + 1]);
+          }
+        }
+      }
+      if (queue.length > 0 && !interrupted) {
+        await delay(200);
+      }
+    }
+  } finally {
+    process.off("SIGINT", onSigint);
+  }
+  return { pages: results, effectivePrefix: pathPrefix };
+}
+function discoverLinks(html, baseUrl, origin, pathPrefix, navLinkSelector) {
+  const $ = cheerio4.load(html);
+  const links = [];
+  const selector = navLinkSelector || "a[href]";
+  $(selector).each((_, el) => {
+    const href = $(el).attr("href");
+    if (!href) return;
+    try {
+      const resolved = new URL(href, baseUrl).href;
+      if (isInBounds(resolved, origin, pathPrefix)) {
+        links.push(resolved);
+      }
+    } catch {
+    }
+  });
+  return [...new Set(links)];
+}
+function discoverSameOrigin(html, baseUrl, origin, navLinkSelector) {
+  const $ = cheerio4.load(html);
+  const links = [];
+  const selector = navLinkSelector || "a[href]";
+  $(selector).each((_, el) => {
+    const href = $(el).attr("href");
+    if (!href) return;
+    try {
+      const resolved = new URL(href, baseUrl).href;
+      if (new URL(resolved).origin === origin) {
+        links.push(resolved);
+      }
+    } catch {
+    }
+  });
+  return [...new Set(links)];
+}
+function discoverSameOriginCustom(html, baseUrl, origin, discoverUrls) {
+  const urls = discoverUrls(html, baseUrl);
+  return [
+    ...new Set(
+      urls.filter((u) => {
+        try {
+          return new URL(u).origin === origin;
+        } catch {
+          return false;
+        }
+      })
+    )
+  ];
+}
+function discoverLinksCustom(html, baseUrl, origin, pathPrefix, discoverUrls) {
+  const urls = discoverUrls(html, baseUrl);
+  return [...new Set(urls.filter((u) => isInBounds(u, origin, pathPrefix)))];
+}
+function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/pipeline/manifest.ts
+import { readFileSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+function buildSourceManifest(name, url, platform, pages, siteMeta) {
+  const manifest = {
+    name,
+    url,
+    platform,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    pages
+  };
+  if (siteMeta) {
+    manifest.display_name = siteMeta.displayName;
+    manifest.description = siteMeta.description;
+    manifest.icon_url = siteMeta.iconUrl;
+    manifest.og_image = siteMeta.ogImage;
+    manifest.language = siteMeta.language;
+    manifest.page_count = pages.length;
+  }
+  return manifest;
+}
+function writeSourceManifest(manifest, outputDir) {
+  mkdirSync2(outputDir, { recursive: true });
+  writeFileSync2(
+    join2(outputDir, "_index.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function loadRootManifest(rootDir) {
+  try {
+    const raw = readFileSync(join2(rootDir, "manifest.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { sources: [] };
+  }
+}
+function updateRootManifest(rootDir, entry) {
+  const manifest = loadRootManifest(rootDir);
+  const idx = manifest.sources.findIndex((s) => s.name === entry.name);
+  if (idx >= 0) {
+    manifest.sources[idx] = entry;
+  } else {
+    manifest.sources.push(entry);
+  }
+  mkdirSync2(rootDir, { recursive: true });
+  writeFileSync2(
+    join2(rootDir, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+}
+
+// src/pipeline/meta-extractor.ts
+import * as cheerio5 from "cheerio";
+function extractSiteMeta(html, url) {
+  const $ = cheerio5.load(html);
+  const origin = new URL(url).origin;
+  return {
+    displayName: extractDisplayName($, url),
+    description: extractDescription($),
+    iconUrl: extractIconUrl($, origin),
+    ogImage: extractOgImage($, origin),
+    language: extractLanguage($)
+  };
+}
+function nonEmpty(value) {
+  return value?.trim() || void 0;
+}
+function extractDisplayName($, url) {
+  const ogSiteName = nonEmpty($('meta[property="og:site_name"]').attr("content"));
+  if (ogSiteName) return ogSiteName;
+  const appName = nonEmpty($('meta[name="application-name"]').attr("content"));
+  if (appName) return appName;
+  const title = nonEmpty($("title").text());
+  if (title) {
+    const parts = title.split(/\s[-|—]\s/);
+    return parts[0].trim();
+  }
+  return new URL(url).hostname;
+}
+function extractDescription($) {
+  const ogDesc = nonEmpty($('meta[property="og:description"]').attr("content"));
+  if (ogDesc) return ogDesc;
+  const metaDesc = nonEmpty($('meta[name="description"]').attr("content"));
+  if (metaDesc) return metaDesc;
+  return "";
+}
+function extractIconUrl($, origin) {
+  const selectors = [
+    'link[rel="apple-touch-icon"]',
+    'link[rel="icon"][type="image/svg+xml"]',
+    'link[rel="icon"]',
+    'link[rel="shortcut icon"]'
+  ];
+  for (const selector of selectors) {
+    const href = nonEmpty($(selector).attr("href"));
+    if (href) return resolveUrl(href, origin);
+  }
+  return `${origin}/favicon.ico`;
+}
+function extractOgImage($, origin) {
+  const ogImage = nonEmpty($('meta[property="og:image"]').attr("content"));
+  if (ogImage) return resolveUrl(ogImage, origin);
+  return null;
+}
+function extractLanguage($) {
+  const htmlLang = nonEmpty($("html").attr("lang"));
+  if (htmlLang) return htmlLang;
+  const ogLocale = nonEmpty($('meta[property="og:locale"]').attr("content"));
+  if (ogLocale) return ogLocale;
+  return null;
+}
+function resolveUrl(href, origin) {
+  if (href.startsWith("http://") || href.startsWith("https://")) return href;
+  if (href.startsWith("//")) return `https:${href}`;
+  if (href.startsWith("/")) return `${origin}${href}`;
+  return `${origin}/${href}`;
+}
+
+// src/commands/fetch.ts
+function resolveOutputMode(output, shouldCrawl, name) {
+  if (!shouldCrawl) {
+    return { mode: "single-file", outputPath: output, outputDir: "" };
+  }
+  if (output && output.endsWith(".md")) {
+    return { mode: "single-file", outputPath: output, outputDir: "" };
+  }
+  if (output) {
+    const dir = output.endsWith("/") ? output : output + "/";
+    return { mode: "directory", outputPath: void 0, outputDir: dir };
+  }
+  return { mode: "directory", outputPath: void 0, outputDir: `.ai/docs/${name}/` };
+}
+var fetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: "Fetch a documentation URL and convert to Markdown"
+  },
+  args: {
+    url: {
+      type: "positional",
+      description: "Documentation URL to convert",
+      required: true
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output file path or directory"
+    },
+    name: {
+      type: "string",
+      description: "Name for this source (auto-derived from hostname if omitted)"
+    },
+    crawl: {
+      type: "boolean",
+      description: "Follow sidebar/nav links",
+      default: false
+    },
+    "max-depth": {
+      type: "string",
+      description: "Maximum crawl depth",
+      default: "2"
+    }
+  },
+  async run({ args }) {
+    const url = args.url;
+    const output = args.output;
+    const shouldCrawl = args.crawl;
+    const maxDepth = parseInt(args["max-depth"], 10);
+    const name = args.name || slugFromUrl(url);
+    const { mode, outputPath, outputDir } = resolveOutputMode(output, shouldCrawl, name);
+    const silent = mode === "single-file" && !outputPath;
+    if (shouldCrawl) {
+      if (!silent) consola2.start(`Crawling from ${url} (max depth: ${maxDepth})...`);
+      const firstHtml = await fetchPage(url);
+      const $ = cheerio6.load(firstHtml);
+      const platformId = resolve(url, $);
+      const strategy = getStrategy(platformId);
+      const navLinkSelector = strategy.navLinkSelector();
+      const crawlResult = await crawl(url, {
+        maxDepth,
+        navLinkSelector,
+        discoverUrls: strategy.discoverUrls?.bind(strategy),
+        onPageFetched: (pageUrl, current, total) => {
+          if (!silent) consola2.info(`[${current}/${total}] ${pageUrl}`);
+        }
+      });
+      const { pages, effectivePrefix } = crawlResult;
+      if (!silent) consola2.success(`Crawled ${pages.length} pages`);
+      if (mode === "directory") {
+        const pageEntries = pages.map((page) => {
+          const { content, title, platform } = extract(page.html, page.url);
+          const md = transform(content);
+          return { url: page.url, title, platform, markdown: md };
+        });
+        const firstPlatform = pageEntries[0]?.platform || "generic";
+        const manifestPages = writePages(pageEntries, outputDir, effectivePrefix);
+        const siteMeta = extractSiteMeta(firstHtml, url);
+        const sourceManifest = buildSourceManifest(name, url, firstPlatform, manifestPages, siteMeta);
+        writeSourceManifest(sourceManifest, outputDir);
+        const rootDir = dirname3(outputDir.replace(/\/$/, ""));
+        updateRootManifest(rootDir, {
+          name,
+          path: name + "/",
+          fetched_at: sourceManifest.fetched_at,
+          display_name: siteMeta.displayName,
+          description: siteMeta.description,
+          icon_url: siteMeta.iconUrl,
+          page_count: manifestPages.length
+        });
+        consola2.success(`Written ${pages.length} pages to ${outputDir}`);
+      } else {
+        const sections = [];
+        let firstTitle = "";
+        let firstPlatform = "";
+        for (const page of pages) {
+          const { content, title, platform } = extract(page.html, page.url);
+          if (!firstTitle) {
+            firstTitle = title;
+            firstPlatform = platform;
+          }
+          const md = transform(content);
+          sections.push(`## ${title}
+
+Source: ${page.url}
+
+${md}`);
+        }
+        const markdown = sections.join("\n\n---\n\n");
+        write(markdown, outputPath, {
+          sourceUrl: url,
+          title: firstTitle,
+          platform: firstPlatform
+        });
+        if (!silent) consola2.success(`Written to ${outputPath}`);
+      }
+    } else {
+      if (!silent) consola2.start(`Fetching ${url}...`);
+      let html = await fetchPage(url);
+      const { content, title, platform } = extract(html, url);
+      if (content.trim().length < 200) {
+        if (!silent) consola2.warn("Content looks thin, retrying with browser...");
+        try {
+          html = await fetchWithBrowser(url);
+          const result = extract(html, url);
+          const markdown2 = transform(result.content);
+          write(markdown2, outputPath, {
+            sourceUrl: url,
+            title: result.title || title,
+            platform: result.platform
+          });
+          if (!silent) consola2.success(`Written to ${outputPath}`);
+          return;
+        } catch (err) {
+          if (err?.code === "ERR_PLAYWRIGHT_NOT_INSTALLED") {
+            consola2.warn(
+              "This page may require a browser to render. Install Playwright:\n  npm install -D playwright && npx playwright install chromium"
+            );
+          } else {
+            consola2.warn("Browser fallback failed, using static content.");
+          }
+        }
+      }
+      if (!silent) consola2.success(`Extracted content (platform: ${platform})`);
+      const markdown = transform(content);
+      write(markdown, outputPath, {
+        sourceUrl: url,
+        title,
+        platform
+      });
+      if (!silent) consola2.success(`Written to ${outputPath}`);
+    }
+  }
+});
+
+// src/commands/add.ts
+import { defineCommand as defineCommand2 } from "citty";
+import { join as join4 } from "path";
+import consola3 from "consola";
+
+// src/config/manager.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync } from "fs";
+import { join as join3, dirname as dirname4 } from "path";
+import yaml from "js-yaml";
+var CONFIG_FILENAME = ".docs2ai.yaml";
+function loadConfig(startDir) {
+  const configPath = findConfigFile(startDir || process.cwd());
+  if (!configPath) return null;
+  const raw = readFileSync2(configPath, "utf-8");
+  const data = yaml.load(raw);
+  const config = {
+    version: data.version ?? 1,
+    outputDir: data.output_dir ?? ".ai/docs",
+    sources: (data.sources ?? []).map(snakeToCamelSource)
+  };
+  return { config, configPath };
+}
+function saveConfig(config, configPath) {
+  const data = {
+    version: config.version,
+    output_dir: config.outputDir,
+    sources: config.sources.map(camelToSnakeSource)
+  };
+  const content = yaml.dump(data, { lineWidth: -1 });
+  writeFileSync3(configPath, content, "utf-8");
+}
+function addSource(config, source) {
+  const idx = config.sources.findIndex((s) => s.name === source.name);
+  if (idx >= 0) {
+    config.sources[idx] = source;
+  } else {
+    config.sources.push(source);
+  }
+}
+function findConfigFile(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join3(dir, CONFIG_FILENAME);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname4(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function snakeToCamelSource(s) {
+  return {
+    name: s.name ?? "",
+    url: s.url ?? "",
+    crawl: s.crawl ?? false,
+    maxDepth: s.max_depth ?? 2,
+    output: s.output ?? ""
+  };
+}
+function camelToSnakeSource(s) {
+  return {
+    name: s.name,
+    url: s.url,
+    crawl: s.crawl,
+    max_depth: s.maxDepth,
+    output: s.output
+  };
+}
+
+// src/commands/add.ts
+var addCommand = defineCommand2({
+  meta: {
+    name: "add",
+    description: "Add a documentation source to .docs2ai.yaml"
+  },
+  args: {
+    url: {
+      type: "positional",
+      description: "Documentation URL to add",
+      required: true
+    },
+    name: {
+      type: "string",
+      description: "Name for this source (auto-derived from hostname if omitted)"
+    },
+    crawl: {
+      type: "boolean",
+      description: "Enable crawl mode for this source",
+      default: false
+    },
+    "max-depth": {
+      type: "string",
+      description: "Maximum crawl depth",
+      default: "2"
+    },
+    output: {
+      type: "string",
+      alias: "o",
+      description: "Output filename or directory"
+    }
+  },
+  run({ args }) {
+    const url = args.url;
+    const shouldCrawl = args.crawl;
+    const maxDepth = parseInt(args["max-depth"], 10);
+    const name = args.name || slugFromUrl(url);
+    const output = args.output || (shouldCrawl ? `${name}/` : `${name}.md`);
+    const existing = loadConfig();
+    let config;
+    let configPath;
+    if (existing) {
+      config = existing.config;
+      configPath = existing.configPath;
+    } else {
+      configPath = join4(process.cwd(), ".docs2ai.yaml");
+      config = { version: 1, outputDir: ".ai/docs", sources: [] };
+    }
+    addSource(config, { name, url, crawl: shouldCrawl, maxDepth, output });
+    saveConfig(config, configPath);
+    consola3.success(`Added source "${name}" \u2192 ${url}`);
+    consola3.info(`Config: ${configPath}`);
+  }
+});
+
+// src/commands/update.ts
+import { defineCommand as defineCommand3 } from "citty";
+import { join as join5, dirname as dirname5 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import * as cheerio7 from "cheerio";
+import consola4 from "consola";
+var updateCommand = defineCommand3({
+  meta: {
+    name: "update",
+    description: "Refresh configured documentation sources"
+  },
+  args: {
+    name: {
+      type: "string",
+      description: "Update only the named source"
+    }
+  },
+  async run({ args }) {
+    const result = loadConfig();
+    if (!result) {
+      consola4.error("No .docs2ai.yaml found. Run `docs2ai add <url>` first.");
+      process.exit(1);
+    }
+    const { config, configPath } = result;
+    const configDir = dirname5(configPath);
+    const filterName = args.name;
+    const sources = filterName ? config.sources.filter((s) => s.name === filterName) : config.sources;
+    if (sources.length === 0) {
+      if (filterName) {
+        consola4.error(`Source "${filterName}" not found in config.`);
+      } else {
+        consola4.error("No sources configured.");
+      }
+      process.exit(1);
+    }
+    for (const source of sources) {
+      const isDirectoryOutput = !source.output.endsWith(".md");
+      consola4.start(`Updating "${source.name}" from ${source.url}...`);
+      if (source.crawl) {
+        const firstHtml = await fetchPage(source.url);
+        const $ = cheerio7.load(firstHtml);
+        const platformId = resolve(source.url, $);
+        const strategy = getStrategy(platformId);
+        const crawlResult = await crawl(source.url, {
+          maxDepth: source.maxDepth,
+          navLinkSelector: strategy.navLinkSelector(),
+          discoverUrls: strategy.discoverUrls?.bind(strategy),
+          onPageFetched: (url, current, total) => {
+            consola4.info(`  [${current}/${total}] ${url}`);
+          }
+        });
+        const { pages, effectivePrefix } = crawlResult;
+        if (isDirectoryOutput) {
+          const outputDir = join5(configDir, config.outputDir, source.output);
+          const pageEntries = pages.map((page) => {
+            const { content, title, platform } = extract(page.html, page.url);
+            const md = transform(content);
+            return { url: page.url, title, platform, markdown: md };
+          });
+          const firstPlatform = pageEntries[0]?.platform || "generic";
+          const manifestPages = writePages(pageEntries, outputDir, effectivePrefix);
+          const siteMeta = extractSiteMeta(firstHtml, source.url);
+          const sourceManifest = buildSourceManifest(
+            source.name,
+            source.url,
+            firstPlatform,
+            manifestPages,
+            siteMeta
+          );
+          writeSourceManifest(sourceManifest, outputDir);
+          const rootDir = join5(configDir, config.outputDir);
+          updateRootManifest(rootDir, {
+            name: source.name,
+            path: source.output,
+            fetched_at: sourceManifest.fetched_at,
+            display_name: siteMeta.displayName,
+            description: siteMeta.description,
+            icon_url: siteMeta.iconUrl,
+            page_count: manifestPages.length
+          });
+          consola4.success(`Updated "${source.name}" \u2192 ${outputDir} (${pages.length} pages)`);
+        } else {
+          const outputPath = join5(configDir, config.outputDir, source.output);
+          mkdirSync3(dirname5(outputPath), { recursive: true });
+          const sections = [];
+          let firstTitle = "";
+          let firstPlatform = "";
+          for (const page of pages) {
+            const { content, title, platform } = extract(page.html, page.url);
+            if (!firstTitle) {
+              firstTitle = title;
+              firstPlatform = platform;
+            }
+            const md = transform(content);
+            sections.push(`## ${title}
+
+Source: ${page.url}
+
+${md}`);
+          }
+          const markdown = sections.join("\n\n---\n\n");
+          write(markdown, outputPath, {
+            sourceUrl: source.url,
+            title: firstTitle,
+            platform: firstPlatform
+          });
+          consola4.success(`Updated "${source.name}" \u2192 ${outputPath}`);
+        }
+      } else {
+        const outputPath = join5(configDir, config.outputDir, source.output);
+        mkdirSync3(dirname5(outputPath), { recursive: true });
+        const html = await fetchPage(source.url);
+        const { content, title, platform } = extract(html, source.url);
+        const markdown = transform(content);
+        write(markdown, outputPath, {
+          sourceUrl: source.url,
+          title,
+          platform
+        });
+        consola4.success(`Updated "${source.name}" \u2192 ${outputPath}`);
+      }
+    }
+  }
+});
+
+// src/commands/list.ts
+import { defineCommand as defineCommand4 } from "citty";
+import consola5 from "consola";
+var listCommand = defineCommand4({
+  meta: {
+    name: "list",
+    description: "List configured documentation sources"
+  },
+  run() {
+    const result = loadConfig();
+    if (!result) {
+      consola5.info("No .docs2ai.yaml found. Run `docs2ai add <url>` to get started.");
+      return;
+    }
+    const { config, configPath } = result;
+    consola5.info(`Config: ${configPath}`);
+    consola5.info(`Output dir: ${config.outputDir}
+`);
+    if (config.sources.length === 0) {
+      consola5.info("No sources configured.");
+      return;
+    }
+    for (const source of config.sources) {
+      const crawlInfo = source.crawl ? ` (crawl, depth: ${source.maxDepth})` : "";
+      console.log(`  ${source.name}${crawlInfo}`);
+      console.log(`    URL:    ${source.url}`);
+      console.log(`    Output: ${source.output}`);
+      console.log();
+    }
+  }
+});
+
+// src/commands/serve.ts
+import { defineCommand as defineCommand5 } from "citty";
+import { resolve as resolve2 } from "path";
+var serveCommand = defineCommand5({
+  meta: {
+    name: "serve",
+    description: "Start an MCP server exposing documentation tools"
+  },
+  args: {
+    dir: {
+      type: "string",
+      alias: "d",
+      description: "Documentation directory to serve",
+      default: ".ai/docs/"
+    }
+  },
+  async run({ args }) {
+    const docsDir = resolve2(process.cwd(), args.dir);
+    const { createMcpServer: createMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const server = createMcpServer2(docsDir);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  }
+});
+
+// src/cli.ts
+process.on("uncaughtException", (err) => {
+  if (err.code === "ERR_PLAYWRIGHT_NOT_INSTALLED") {
+    consola6.error(err.message);
+  } else {
+    consola6.error(err.message || err);
+  }
+  process.exit(1);
+});
+process.on("unhandledRejection", (err) => {
+  if (err?.code === "ERR_PLAYWRIGHT_NOT_INSTALLED") {
+    consola6.error(err.message);
+  } else {
+    consola6.error(err?.message || err);
+  }
+  process.exit(1);
+});
+var subCommands = {
+  add: addCommand,
+  update: updateCommand,
+  list: listCommand,
+  serve: serveCommand
+};
+var firstArg = process.argv[2];
+var isSubCommand = firstArg && firstArg in subCommands;
+if (isSubCommand) {
+  const main = defineCommand6({
+    meta: {
+      name: "docs2ai",
+      version: "0.1.0",
+      description: "Convert documentation URLs into AI-ready Markdown files"
+    },
+    subCommands
+  });
+  runMain(main);
+} else if (firstArg && !firstArg.startsWith("-") && firstArg !== "--help") {
+  runCommand(fetchCommand, { rawArgs: process.argv.slice(2) });
+} else {
+  const main = defineCommand6({
+    meta: {
+      name: "docs2ai",
+      version: "0.1.0",
+      description: "Convert documentation URLs into AI-ready Markdown files"
+    },
+    subCommands,
+    run() {
+      console.log("Usage: docs2ai <url> [-o output.md] [--crawl]");
+      console.log("       docs2ai add <url> [--name name] [--crawl]");
+      console.log("       docs2ai update [--name name]");
+      console.log("       docs2ai list");
+      console.log("       docs2ai serve [-d dir]");
+      console.log("\nRun `docs2ai --help` for full usage.");
+    }
+  });
+  runMain(main);
+}
+//# sourceMappingURL=cli.mjs.map