nuxt-ai-ready 0.0.0

package/dist/runtime/server/mcp/prompts/find-information.js

@@ -0,0 +1,57 @@
+import { defineMcpPrompt } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpPrompt({
+  name: "find_information",
+  description: "Find information about a specific topic by searching site pages and retrieving relevant content",
+  arguments: [
+    {
+      name: "topic",
+      description: "Topic, feature, or question to find information about",
+      required: true
+    },
+    {
+      name: "detail",
+      description: "Level of detail needed: summary, detailed, or comprehensive",
+      required: false
+    }
+  ],
+  handler: async ({ topic, detail = "detailed" }) => {
+    const searchLower = topic.toLowerCase();
+    const seenRoutes = /* @__PURE__ */ new Set();
+    const relevantPages = [];
+    for await (const doc of streamBulkDocuments()) {
+      if (seenRoutes.has(doc.route))
+        continue;
+      const matches = doc.title?.toLowerCase().includes(searchLower) || doc.description?.toLowerCase().includes(searchLower) || doc.route?.toLowerCase().includes(searchLower);
+      if (matches) {
+        seenRoutes.add(doc.route);
+        relevantPages.push({
+          route: doc.route,
+          title: doc.title,
+          description: doc.description
+        });
+        if (relevantPages.length >= 10)
+          break;
+      }
+    }
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Help me find information about: "${topic}"
+
+Here are the relevant pages found: ${JSON.stringify(relevantPages, null, 2)}
+
+Please:
+1. Review the page titles and descriptions to identify the most relevant ones
+2. Use get_page to retrieve full content of the top 2-3 most relevant pages
+3. ${detail === "summary" ? "Provide a concise summary (2-3 paragraphs)" : detail === "comprehensive" ? "Provide a comprehensive explanation with all details and examples from the pages" : "Provide a detailed explanation covering the key points"}
+4. Always cite which pages the information came from`
+          }
+        }
+      ]
+    };
+  }
+});

package/dist/runtime/server/mcp/prompts/search-content.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/prompts/search-content.js

@@ -0,0 +1,58 @@
+import { defineMcpPrompt } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpPrompt({
+  name: "browse_pages",
+  description: "Browse and discover pages by topic, with results ready for exploration",
+  arguments: [
+    {
+      name: "topic",
+      description: "Topic or keyword to search for in page titles/descriptions",
+      required: true
+    },
+    {
+      name: "maxResults",
+      description: "Maximum number of pages to retrieve",
+      required: false
+    }
+  ],
+  handler: async ({ topic, maxResults = 10 }) => {
+    const searchLower = topic.toLowerCase();
+    const seenRoutes = /* @__PURE__ */ new Set();
+    const filteredPages = [];
+    let total = 0;
+    for await (const doc of streamBulkDocuments()) {
+      total++;
+      if (seenRoutes.has(doc.route))
+        continue;
+      const matches = doc.title?.toLowerCase().includes(searchLower) || doc.description?.toLowerCase().includes(searchLower) || doc.route?.toLowerCase().includes(searchLower);
+      if (matches) {
+        seenRoutes.add(doc.route);
+        filteredPages.push({
+          route: doc.route,
+          title: doc.title,
+          description: doc.description
+        });
+        if (filteredPages.length >= maxResults)
+          break;
+      }
+    }
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Help the user find pages about: "${topic}"
+
+Here are ${filteredPages.length} pages found (out of ${total} total pages): ${JSON.stringify(filteredPages, null, 2)}
+
+Please:
+1. Review the filtered results and identify the most relevant pages
+2. If specific pages look relevant, use get_page to retrieve their full content
+3. Summarize findings and reference the source pages`
+          }
+        }
+      ]
+    };
+  }
+});

package/dist/runtime/server/mcp/resources/all-content.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/resources/all-content.js

@@ -0,0 +1,14 @@
+import { defineMcpResource, textResult } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpResource({
+  uri: "content://all",
+  name: "All Site Content",
+  description: "Complete indexed site content in JSONL format (newline-delimited JSON)",
+  mimeType: "application/x-ndjson",
+  handler: async () => {
+    const lines = [];
+    for await (const doc of streamBulkDocuments())
+      lines.push(JSON.stringify(doc));
+    return textResult(lines.join("\n"));
+  }
+});

package/dist/runtime/server/mcp/resources/pages.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/resources/pages.js

@@ -0,0 +1,23 @@
+import { defineMcpResource, jsonResult } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpResource({
+  uri: "pages://list",
+  name: "All Pages",
+  description: "Complete list of all indexed pages with basic metadata (route, title, description)",
+  mimeType: "application/json",
+  handler: async () => {
+    const pages = [];
+    for await (const doc of streamBulkDocuments()) {
+      pages.push({
+        route: doc.route,
+        title: doc.title,
+        description: doc.description,
+        id: doc.id
+      });
+    }
+    return jsonResult({
+      total: pages.length,
+      pages
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/get-page.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/get-page.js

@@ -0,0 +1,42 @@
+import { defineMcpTool, errorResult, jsonResult } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpTool({
+  name: "get_page",
+  description: `Retrieves the full content and details of a specific page by its route.
+
+WHEN TO USE: Use this tool when you know the EXACT route to a page. Common scenarios:
+- User asks for a specific page: "Get the /about page"
+- You found a relevant route from list_pages and want full content
+- You need complete page details including markdown content
+
+WHEN NOT TO USE: If you don't know the exact route, use list_pages first to discover available pages.
+
+OUTPUT: Returns complete page data including:
+- route: Page URL path
+- title: Page title
+- description: Page meta description
+- markdown: Full markdown content
+- headings: Document structure
+- id: Document identifier
+- chunkIds: Associated chunk identifiers`,
+  parameters: {
+    type: "object",
+    properties: {
+      route: {
+        type: "string",
+        description: 'The exact route/path to the page (e.g., "/docs/getting-started", "/about", "/blog/my-post")'
+      }
+    },
+    required: ["route"]
+  },
+  handler: async ({ route }) => {
+    const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
+    const cleanRoute = normalizedRoute.replace(/\/$/, "") || "/";
+    for await (const doc of streamBulkDocuments()) {
+      const docRoute = doc.route?.replace(/\/$/, "") || "/";
+      if (docRoute === cleanRoute || doc.route === route)
+        return jsonResult(doc);
+    }
+    return errorResult(`Page not found: ${route}. Use list_pages to discover available pages.`);
+  }
+});

package/dist/runtime/server/mcp/tools/list-pages.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/list-pages.js

@@ -0,0 +1,78 @@
+import { defineMcpTool, jsonResult } from "#imports";
+import { streamBulkDocuments } from "../../utils/db.js";
+export default defineMcpTool({
+  name: "list_pages",
+  description: `Lists all indexed pages from the site with configurable output fields.
+
+WHEN TO USE: Use this tool when you need to DISCOVER or SEARCH for pages. Common scenarios:
+- "What pages are available?" - browse all pages
+- "Find pages about X topic" - search by title/description
+- "Show me the site structure" - explore content organization
+- "What documentation exists?" - discover available content
+
+WHEN NOT TO USE: If you already know the exact page route, use get_page directly.
+
+WORKFLOW: This tool returns page metadata (route, title, description, etc.). After finding relevant pages, use get_page to retrieve full content.
+
+FIELD OPTIONS: Control which fields to include in the output:
+- route: Page URL path (always included)
+- title: Page title
+- description: Page meta description
+- headings: Document structure (h1, h2, h3, etc.)
+- markdown: Full markdown content (warning: can be large, avoid unless needed)
+- id: Document identifier
+- chunkIds: Associated chunk identifiers`,
+  parameters: {
+    type: "object",
+    properties: {
+      fields: {
+        type: "array",
+        description: "Fields to include in output. Defaults to [route, title, description]",
+        items: {
+          type: "string",
+          enum: ["route", "title", "description", "headings", "markdown", "id", "chunkIds"]
+        },
+        default: ["route", "title", "description"]
+      },
+      search: {
+        type: "string",
+        description: "Optional search term to filter pages by title or description"
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of pages to return",
+        minimum: 1,
+        maximum: 1e3,
+        default: 100
+      }
+    }
+  },
+  handler: async ({ fields = ["route", "title", "description"], search, limit = 100 }) => {
+    const searchLower = search?.toLowerCase();
+    const result = [];
+    let total = 0;
+    let filtered = 0;
+    for await (const doc of streamBulkDocuments()) {
+      total++;
+      if (searchLower) {
+        const matches = doc.title?.toLowerCase().includes(searchLower) || doc.description?.toLowerCase().includes(searchLower) || doc.route?.toLowerCase().includes(searchLower);
+        if (!matches)
+          continue;
+      }
+      filtered++;
+      if (result.length < limit) {
+        const projected = { route: doc.route };
+        fields.forEach((field) => {
+          if (field !== "route" && field in doc)
+            projected[field] = doc[field];
+        });
+        result.push(projected);
+      }
+    }
+    return jsonResult({
+      total,
+      filtered,
+      pages: result
+    });
+  }
+});

package/dist/runtime/server/middleware/mdream.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | import("h3").H3Error<unknown> | undefined>>;
+export default _default;

package/dist/runtime/server/middleware/mdream.js

@@ -0,0 +1,132 @@
+import { withSiteUrl } from "#site-config/server/composables/utils";
+import { createError, defineEventHandler, getHeader, setHeader } from "h3";
+import { htmlToMarkdown } from "mdream";
+import { extractionPlugin } from "mdream/plugins";
+import { withMinimalPreset } from "mdream/preset/minimal";
+import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
+import { logger } from "../logger.js";
+function shouldServeMarkdown(event) {
+  const accept = getHeader(event, "accept") || "";
+  const secFetchDest = getHeader(event, "sec-fetch-dest") || "";
+  if (secFetchDest === "document") {
+    return false;
+  }
+  if (accept.includes("text/html")) {
+    return false;
+  }
+  return accept.includes("*/*") || accept.includes("text/markdown");
+}
+async function convertHtmlToMarkdown(html, url, config, route, event) {
+  const nitroApp = useNitroApp();
+  let title = "";
+  let description = "";
+  const extractPlugin = extractionPlugin({
+    title(el) {
+      title = el.textContent;
+    },
+    'meta[name="description"]': (el) => {
+      description = el.attributes.content || "";
+    }
+  });
+  let options = {
+    origin: url,
+    ...config.mdreamOptions
+  };
+  if (config.mdreamOptions?.preset === "minimal") {
+    options = withMinimalPreset(options);
+    options.plugins = [extractPlugin, ...options.plugins || []];
+  } else {
+    options.plugins = [extractPlugin, ...options.plugins || []];
+  }
+  await nitroApp.hooks.callHook("ai-ready:mdreamConfig", options);
+  let markdown = htmlToMarkdown(html, options);
+  const context = {
+    html,
+    markdown,
+    route,
+    title,
+    description,
+    isPrerender: Boolean(import.meta.prerender),
+    event
+  };
+  await nitroApp.hooks.callHook("ai-ready:markdown", context);
+  markdown = context.markdown;
+  return { markdown, title, description };
+}
+export default defineEventHandler(async (event) => {
+  let path = event.path;
+  const config = useRuntimeConfig(event)["nuxt-ai-ready"];
+  if (path.startsWith("/api") || path.startsWith("/_") || path.startsWith("/@")) {
+    return;
+  }
+  const lastSegment = path.split("/").pop() || "";
+  const hasExtension = lastSegment.includes(".");
+  const extension = hasExtension ? lastSegment.substring(lastSegment.lastIndexOf(".")) : "";
+  if (hasExtension && extension !== ".md") {
+    return;
+  }
+  const hasMarkdownExtension = path.endsWith(".md");
+  const clientPrefersMarkdown = shouldServeMarkdown(event);
+  if (!hasMarkdownExtension && !clientPrefersMarkdown) {
+    return;
+  }
+  if (hasMarkdownExtension) {
+    path = path.slice(0, -3);
+  }
+  if (path === "/index") {
+    path = "/";
+  }
+  let html;
+  try {
+    const response = await globalThis.$fetch.raw(path);
+    if (!response.ok) {
+      if (hasMarkdownExtension) {
+        return createError({
+          statusCode: response.status,
+          statusMessage: response.statusText,
+          message: `Failed to fetch HTML for ${path}`
+        });
+      }
+      return;
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("text/html")) {
+      if (hasMarkdownExtension) {
+        return createError({
+          statusCode: 415,
+          statusMessage: "Unsupported Media Type",
+          message: `Expected text/html but got ${contentType} for ${path}`
+        });
+      }
+      return;
+    }
+    html = response._data;
+  } catch (e) {
+    logger.error(`Failed to fetch HTML for ${path}`, e);
+    if (hasMarkdownExtension) {
+      return createError({
+        statusCode: 500,
+        statusMessage: "Internal Server Error",
+        message: `Failed to fetch HTML for ${path}`
+      });
+    }
+    return;
+  }
+  const result = await convertHtmlToMarkdown(
+    html,
+    withSiteUrl(event, path),
+    config,
+    path,
+    event
+  );
+  setHeader(event, "content-type", "text/markdown; charset=utf-8");
+  if (!import.meta.prerender && config.markdownCacheHeaders) {
+    const { maxAge, swr } = config.markdownCacheHeaders;
+    const cacheControl = swr ? `public, max-age=${maxAge}, stale-while-revalidate=${maxAge}` : `public, max-age=${maxAge}`;
+    setHeader(event, "cache-control", cacheControl);
+  }
+  if (import.meta.prerender) {
+    return JSON.stringify(result);
+  }
+  return result.markdown;
+});

package/dist/runtime/server/routes/llms.txt.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/routes/llms.txt.get.js

@@ -0,0 +1,23 @@
+import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
+import { eventHandler, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { normalizeLlmsTxtConfig } from "../../../utils";
+export default eventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
+  const siteConfig = getSiteConfig(event);
+  const llmsTxtConfig = runtimeConfig.llmsTxt;
+  const parts = [];
+  parts.push(`# ${siteConfig.name || siteConfig.url}`);
+  if (siteConfig.description) {
+    parts.push(`
+> ${siteConfig.description}
+`);
+  }
+  parts.push("<!-- Pages will be generated at build time -->\n");
+  const normalizedContent = normalizeLlmsTxtConfig(llmsTxtConfig);
+  if (normalizedContent) {
+    parts.push(normalizedContent);
+  }
+  setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+  return parts.join("\n");
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/server/utils/db.d.ts

@@ -0,0 +1,8 @@
+import type { BulkChunk } from '../../types.js';
+declare module 'nitropack' {
+    interface NitroApp {
+        _bulkDocuments?: Promise<BulkChunk[]>;
+    }
+}
+export declare function streamBulkDocuments(): AsyncGenerator<BulkChunk>;
+export declare function useBulkDocuments(): Promise<BulkChunk[]>;

package/dist/runtime/server/utils/db.js

@@ -0,0 +1,48 @@
+import { useNitroApp, useRuntimeConfig } from "nitropack/runtime";
+import { logger } from "../logger.js";
+export async function* streamBulkDocuments() {
+  const config = useRuntimeConfig();
+  const bulkRoute = config["nuxt-ai-ready"]?.bulkRoute;
+  const response = await fetch(bulkRoute).catch((err) => {
+    logger.warn("Documents loading failed:", err);
+    throw err;
+  });
+  if (!response.ok || !response.body)
+    throw new Error(`Failed to fetch bulk documents: ${response.statusText}`);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line)
+          yield JSON.parse(line);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    }
+    if (buffer.trim())
+      yield JSON.parse(buffer.trim());
+  } finally {
+    reader.releaseLock();
+  }
+}
+export async function useBulkDocuments() {
+  const nitroApp = useNitroApp();
+  if (nitroApp._bulkDocuments)
+    return await nitroApp._bulkDocuments;
+  logger.debug("Lazy loading bulk documents...");
+  nitroApp._bulkDocuments = (async () => {
+    const documents = [];
+    for await (const chunk of streamBulkDocuments())
+      documents.push(chunk);
+    return documents;
+  })();
+  return await nitroApp._bulkDocuments;
+}