nuxt-ai-ready 0.4.4 → 0.5.1

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=4.0.0"
   },
   "configKey": "aiReady",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { appendFile, mkdir, writeFile, stat, access } from 'node:fs/promises';
+import { appendFile, mkdir, writeFile, readFile, stat, access } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { useLogger, useNuxt, defineNuxtModule, createResolver, addTypeTemplate, hasNuxtModule, addServerHandler, addPlugin } from '@nuxt/kit';
 import defu from 'defu';
@@ -231,7 +231,7 @@ async function crawlSitemapEntries(state, nuxt, nitro, entries) {
     try {
       parsed = JSON.parse(res);
     } catch (err) {
-      logger.debug(`Skipping ${route}: Response is not JSON (likely HTML instead of markdown conversion)`);
+      logger.debug(`Skipping ${route}: Response is not JSON (likely HTML instead of markdown conversion)`, err);
       continue;
     }
     await processMarkdownRoute(state, nuxt, route, parsed, lastmod);
@@ -361,6 +361,26 @@ function setupPrerenderHandler(pageDataPath, siteInfo, llmsTxtConfig) {
         }
         logger.debug(`Wrote ${state.errorRoutes.size} error routes to page data`);
       }
+      if (state.pageDataPath) {
+        const jsonlContent = await readFile(state.pageDataPath, "utf-8").catch(() => "");
+        if (jsonlContent) {
+          const entries = jsonlContent.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+          const pages = entries.filter((e) => !e._error).map((p) => ({
+            route: p.route,
+            title: p.title,
+            description: p.description,
+            headings: p.headings,
+            updatedAt: p.updatedAt
+          }));
+          const errorRoutes = entries.filter((e) => e._error).map((e) => e.route);
+          const jsonContent = JSON.stringify({ pages, errorRoutes });
+          const publicDataDir = join(nitro.options.output.publicDir, "__ai-ready");
+          await mkdir(publicDataDir, { recursive: true });
+          const publicJsonPath = join(publicDataDir, "pages.json");
+          await writeFile(publicJsonPath, jsonContent, "utf-8");
+          logger.debug(`Wrote ${pages.length} pages to __ai-ready/pages.json`);
+        }
+      }
       const llmsStats = await prerenderRoute(nitro, "/llms.txt");
       const llmsFullStats = await stat(state.llmsFullTxtPath);
       const kb = (b) => (b / 1024).toFixed(1);
@@ -480,14 +500,17 @@ declare module 'nitropack/types' {
 }
 
 declare module '#ai-ready-virtual/read-page-data.mjs' {
-  export function readPageDataFromFilesystem(): Promise<Array<{
-    route: string
-    title: string
-    description: string
-    headings: string
-    updatedAt: string
-    markdown: string
-  }> | null>
+  export function readPageDataFromFilesystem(): Promise<{
+    pages: Array<{
+      route: string
+      title: string
+      description: string
+      headings: string
+      updatedAt: string
+      markdown: string
+    }>
+    errorRoutes: string[]
+  }>
 }
 
 declare module '#ai-ready-virtual/page-data.mjs' {
@@ -597,6 +620,9 @@ export const errorRoutes = []`;
     }
     addServerHandler({ route: "/llms.txt", handler: resolve("./runtime/server/routes/llms.txt.get") });
     addServerHandler({ route: "/llms-full.txt", handler: resolve("./runtime/server/routes/llms-full.txt.get") });
+    if (config.debug) {
+      addServerHandler({ route: "/__ai-ready-debug", handler: resolve("./runtime/server/routes/__ai-ready-debug.get") });
+    }
     const isStatic = nuxt.options.nitro.static || nuxt.options._generate || false;
     const hasPrerenderedRoutes = nuxt.options.nitro.prerender?.routes?.length;
     const isSPA = nuxt.options.ssr === false;

package/dist/runtime/server/routes/__ai-ready-debug.get.d.ts

@@ -0,0 +1,46 @@
+interface DebugInfo {
+    version: string;
+    environment: {
+        isDev: boolean;
+        isPrerender: boolean;
+        mode: 'development' | 'prerender' | 'production';
+    };
+    config: {
+        debug: boolean;
+        cacheMaxAgeSeconds: number;
+        mdreamOptions: unknown;
+    };
+    pageData: {
+        source: string;
+        pageCount: number;
+        pages: Array<{
+            route: string;
+            title: string;
+            hasDescription: boolean;
+            hasHeadings: boolean;
+        }>;
+        errorRoutes: string[];
+    };
+    jsonFile: {
+        available: boolean;
+        pageCount: number;
+        source: string;
+    };
+    virtualModules: {
+        pageDataModule: {
+            available: boolean;
+            pagesCount: number;
+            errorRoutesCount: number;
+        };
+        readPageDataModule: {
+            available: boolean;
+            note: string;
+        };
+    };
+    diagnostics: {
+        issues: string[];
+        suggestions: string[];
+    };
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<DebugInfo>>;
+export default _default;

package/dist/runtime/server/routes/__ai-ready-debug.get.js

@@ -0,0 +1,114 @@
+import { createError, eventHandler, setHeader } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { getErrorRoutes, getPages, getPagesList } from "../utils/pageData.js";
+export default eventHandler(async (event) => {
+  const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
+  if (!runtimeConfig.debug) {
+    throw createError({
+      statusCode: 404,
+      message: "Not Found"
+    });
+  }
+  const isDev = import.meta.dev;
+  const isPrerender = import.meta.prerender ?? false;
+  let mode;
+  if (isDev) {
+    mode = "development";
+  } else if (isPrerender) {
+    mode = "prerender";
+  } else {
+    mode = "production";
+  }
+  const pages = await getPages();
+  const pagesList = await getPagesList();
+  const errorRoutes = await getErrorRoutes();
+  let source;
+  if (isDev) {
+    source = "empty (dev mode returns empty Map)";
+  } else if (isPrerender) {
+    source = "#ai-ready-virtual/read-page-data.mjs (reads from filesystem)";
+  } else {
+    source = "fetch('/__ai-ready/pages.json') (public directory)";
+  }
+  let pageDataModuleInfo = { available: false, pagesCount: 0, errorRoutesCount: 0 };
+  let readPageDataModuleInfo = { available: false, note: "" };
+  try {
+    const m = await import("#ai-ready-virtual/page-data.mjs");
+    pageDataModuleInfo = {
+      available: true,
+      pagesCount: Array.isArray(m.pages) ? m.pages.length : 0,
+      errorRoutesCount: Array.isArray(m.errorRoutes) ? m.errorRoutes.length : 0
+    };
+  } catch {
+    pageDataModuleInfo.available = false;
+  }
+  try {
+    const m = await import("#ai-ready-virtual/read-page-data.mjs");
+    readPageDataModuleInfo = {
+      available: typeof m.readPageDataFromFilesystem === "function",
+      note: isPrerender ? "Active - reading from filesystem" : "Available but only works during prerender"
+    };
+  } catch {
+    readPageDataModuleInfo = { available: false, note: "Module not available" };
+  }
+  const publicData = await globalThis.$fetch("/__ai-ready/pages.json", {
+    baseURL: "/"
+  }).catch(() => null);
+  const jsonFileStatus = {
+    available: !!publicData,
+    pageCount: publicData?.pages?.length ?? 0,
+    source: "fetch('/__ai-ready/pages.json')"
+  };
+  const issues = [];
+  const suggestions = [];
+  if (mode === "development") {
+    issues.push("Development mode: page data is intentionally empty");
+    suggestions.push("Run `nuxi generate` or `nuxi build --prerender` to generate page data");
+  } else if (mode === "production" && pages.size === 0) {
+    if (!jsonFileStatus.available) {
+      issues.push("Production mode with no page data - /__ai-ready/pages.json not found");
+      suggestions.push("Run `nuxi generate` or `nuxi build --prerender` to generate the page data");
+    } else {
+      issues.push("pages.json exists but returned empty page data");
+      suggestions.push("Check if pages were prerendered correctly");
+    }
+  } else if (mode === "prerender" && pages.size === 0) {
+    issues.push("Prerender mode but no pages found");
+    suggestions.push("Check if page-data.jsonl exists in .nuxt/.data/ai-ready/");
+  }
+  const debugInfo = {
+    version: runtimeConfig.version || "unknown",
+    environment: {
+      isDev,
+      isPrerender,
+      mode
+    },
+    config: {
+      debug: runtimeConfig.debug,
+      cacheMaxAgeSeconds: runtimeConfig.cacheMaxAgeSeconds,
+      mdreamOptions: runtimeConfig.mdreamOptions
+    },
+    pageData: {
+      source,
+      pageCount: pages.size,
+      pages: pagesList.map((p) => ({
+        route: p.route,
+        title: p.title,
+        hasDescription: !!p.description,
+        hasHeadings: !!p.headings
+      })),
+      errorRoutes: Array.from(errorRoutes)
+    },
+    jsonFile: jsonFileStatus,
+    virtualModules: {
+      pageDataModule: pageDataModuleInfo,
+      readPageDataModule: readPageDataModuleInfo
+    },
+    diagnostics: {
+      issues,
+      suggestions
+    }
+  };
+  setHeader(event, "Content-Type", "application/json; charset=utf-8");
+  return debugInfo;
+});

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

@@ -10,8 +10,6 @@ export interface PageEntry {
 export interface PageData extends PageEntry {
     markdown: string;
 }
-/** Read page data - returns page data indexed by route */
-export declare function getPages(): Promise<Map<string, PageEntry>>;
 /** Page list item for MCP tools/resources */
 export interface PageListItem {
     route: string;
@@ -19,7 +17,9 @@ export interface PageListItem {
     description: string;
     headings?: string;
 }
-/** Get pages as flat list for MCP consumption */
-export declare function getPagesList(): Promise<PageListItem[]>;
+/** Read page data - returns page data indexed by route */
+export declare function getPages(): Promise<Map<string, PageEntry>>;
 /** Get error routes detected during prerender */
 export declare function getErrorRoutes(): Promise<Set<string>>;
+/** Get pages as flat list for MCP consumption */
+export declare function getPagesList(): Promise<PageListItem[]>;

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

@@ -1,22 +1,16 @@
 export async function getPages() {
   if (import.meta.dev)
     return /* @__PURE__ */ new Map();
-  if (import.meta.prerender) {
-    const data = await readPrerenderedData();
-    return data.pages;
-  }
-  const m = await import("#ai-ready-virtual/page-data.mjs");
-  return m.pages?.length ? new Map(m.pages.map((p) => [p.route, p])) : /* @__PURE__ */ new Map();
+  if (import.meta.prerender)
+    return (await readPrerenderedData()).pages;
+  return (await readServerAssets()).pages;
 }
-async function readPrerenderedData() {
-  if (!import.meta.prerender)
-    return { pages: /* @__PURE__ */ new Map(), errorRoutes: /* @__PURE__ */ new Set() };
-  const m = await import("#ai-ready-virtual/read-page-data.mjs");
-  const data = await m.readPageDataFromFilesystem();
-  return {
-    pages: data.pages?.length ? new Map(data.pages.map((p) => [p.route, p])) : /* @__PURE__ */ new Map(),
-    errorRoutes: new Set(data.errorRoutes || [])
-  };
+export async function getErrorRoutes() {
+  if (import.meta.dev)
+    return /* @__PURE__ */ new Set();
+  if (import.meta.prerender)
+    return (await readPrerenderedData()).errorRoutes;
+  return (await readServerAssets()).errorRoutes;
 }
 export async function getPagesList() {
   const pages = await getPages();
@@ -27,13 +21,22 @@ export async function getPagesList() {
     headings: p.headings || void 0
   }));
 }
-export async function getErrorRoutes() {
-  if (import.meta.dev)
-    return /* @__PURE__ */ new Set();
-  if (import.meta.prerender) {
-    const data = await readPrerenderedData();
-    return data.errorRoutes;
-  }
-  const m = await import("#ai-ready-virtual/page-data.mjs");
-  return new Set(m.errorRoutes || []);
+async function readServerAssets() {
+  const data = await globalThis.$fetch("/__ai-ready/pages.json", {
+    baseURL: "/"
+  }).catch(() => null);
+  if (!data)
+    return { pages: /* @__PURE__ */ new Map(), errorRoutes: /* @__PURE__ */ new Set() };
+  return {
+    pages: new Map(data.pages?.map((p) => [p.route, p]) || []),
+    errorRoutes: new Set(data.errorRoutes || [])
+  };
+}
+async function readPrerenderedData() {
+  const m = await import("#ai-ready-virtual/read-page-data.mjs");
+  const data = await m.readPageDataFromFilesystem();
+  return {
+    pages: new Map(data.pages?.map((p) => [p.route, p]) || []),
+    errorRoutes: new Set(data.errorRoutes || [])
+  };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -50,21 +50,22 @@
     "unstorage": "^1.17.3"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.7.1",
+    "@antfu/eslint-config": "^6.7.3",
     "@arethetypeswrong/cli": "^0.18.2",
     "@headlessui/vue": "^1.7.23",
-    "@nuxt/content": "^3.9.0",
+    "@nuxt/content": "^3.10.0",
     "@nuxt/devtools-ui-kit": "^3.1.1",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/test-utils": "^3.21.0",
     "@nuxtjs/color-mode": "^4.0.0",
     "@nuxtjs/eslint-config-typescript": "^12.1.0",
     "@nuxtjs/i18n": "^10.2.1",
-    "@nuxtjs/mcp-toolkit": "^0.5.2",
+    "@nuxtjs/mcp-toolkit": "^0.6.0",
     "@nuxtjs/robots": "^5.6.7",
     "@nuxtjs/sitemap": "7.5.0",
     "@vitest/coverage-v8": "^4.0.16",
     "@vueuse/nuxt": "^14.1.0",
+    "agents": "^0.3.0",
     "better-sqlite3": "^12.5.0",
     "bumpp": "^10.3.2",
     "eslint": "^9.39.2",
@@ -79,7 +80,7 @@
     "vitest": "^4.0.16",
     "vue": "^3.5.26",
     "vue-router": "^4.6.4",
-    "vue-tsc": "^3.1.8",
+    "vue-tsc": "^3.2.1",
     "zod": "^4.2.1"
   },
   "resolutions": {