nuxt-ai-ready 0.5.2 → 0.6.0

package/README.md

@@ -20,7 +20,8 @@ Nuxt AI Ready implements both. It converts your pages to markdown, generates llm
 - 🚀 **On-Demand Markdown**: Any route available as `.md` (e.g., `/about` → `/about.md`), automatically served to AI crawlers
 - 📡 **Content Signals**: Configure AI training/search/input permissions via [Nuxt Robots](https://nuxtseo.com/robots)
 - 🌐 **Sitemap Integration**: Index AI-allowed pages via [Nuxt Sitemap](https://nuxtseo.com/sitemap)
-- ⚡ **MCP Server**: `list_pages` and `search_pages_fuzzy` tools for AI agents to query your site
+- ⚡ **MCP Server**: `list_pages` and `search_pages` tools with FTS5 full-text search
+- 🗄️ **Runtime Indexing**: Index pages on-demand without prerendering, with SQLite/D1/LibSQL support
 - 🧠 **[RAG Ready](https://nuxtseo.com/ai-ready/advanced/rag-example)**: Markdown output optimized for vectorizing and semantic search
 
 ## Installation

package/dist/module.d.mts

@@ -7,6 +7,7 @@ interface ParsedMarkdownResult {
     title: string;
     description: string;
     headings: Array<Record<string, string>>;
+    keywords?: string[];
     updatedAt?: string;
 }
 
@@ -31,6 +32,14 @@ interface ModulePublicRuntimeConfig {
     version: string;
     mdreamOptions: ModuleOptions['mdreamOptions'];
     markdownCacheHeaders: Required<NonNullable<ModuleOptions['markdownCacheHeaders']>>;
+    ttl: number;
+    database: {
+        type: 'sqlite' | 'd1' | 'libsql';
+        filename?: string;
+        bindingName?: string;
+        url?: string;
+        authToken?: string;
+    };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/module.json

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

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { appendFile, mkdir, writeFile, readFile, stat, access } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { join as join$1, dirname } from 'node:path';
 import { useLogger, useNuxt, defineNuxtModule, createResolver, addTypeTemplate, hasNuxtModule, addServerHandler, addPlugin } from '@nuxt/kit';
 import defu from 'defu';
 import { useSiteConfig, installNuxtSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
@@ -10,6 +10,7 @@ import { isTest, isCI } from 'std-env';
 import { parseSitemapXml } from '@nuxtjs/sitemap/utils';
 import { colorize } from 'consola/utils';
 import { withBase } from 'ufo';
+import { join, isAbsolute } from 'pathe';
 
 const logger = useLogger("nuxt-ai-ready");
 
@@ -64,6 +65,45 @@ function hookNuxtSeoProLicense() {
   }
 }
 
+async function resolveDatabaseAdapter(type, _opts) {
+  const connectors = {
+    d1: "db0/connectors/cloudflare-d1",
+    libsql: "db0/connectors/libsql/node"
+  };
+  if (type !== "sqlite" && connectors[type]) {
+    return connectors[type];
+  }
+  if (process.versions.bun) {
+    return "db0/connectors/bun-sqlite";
+  }
+  const nodeVersion = Number.parseInt(process.versions.node?.split(".")[0] || "0");
+  if (nodeVersion >= 22) {
+    return "db0/connectors/node-sqlite";
+  }
+  return "db0/connectors/better-sqlite3";
+}
+function refineDatabaseConfig(config, rootDir) {
+  const type = config.type || "sqlite";
+  if (type === "sqlite") {
+    const filename = config.filename || ".data/ai-ready/pages.db";
+    return {
+      type: "sqlite",
+      filename: isAbsolute(filename) ? filename : join(rootDir, filename)
+    };
+  }
+  if (type === "d1") {
+    return {
+      type: "d1",
+      bindingName: config.bindingName || "AI_READY_DB"
+    };
+  }
+  return {
+    type: "libsql",
+    url: config.url,
+    authToken: config.authToken
+  };
+}
+
 function normalizeLink(link) {
   const parts = [];
   parts.push(`- [${link.title}](${link.href})`);
@@ -178,7 +218,7 @@ function formatPageForLlmsFullTxt(route, title, description, markdown, siteUrl)
 `;
 }
 async function processMarkdownRoute(state, nuxt, route, parsed, lastmod, options) {
-  const { markdown, title, description, headings, updatedAt: metaUpdatedAt } = parsed;
+  const { markdown, title, description, headings, keywords, updatedAt: metaUpdatedAt } = parsed;
   let updatedAt = (lastmod instanceof Date ? lastmod.toISOString() : lastmod) || (/* @__PURE__ */ new Date()).toISOString();
   if (metaUpdatedAt) {
     const parsedDate = new Date(metaUpdatedAt);
@@ -192,6 +232,7 @@ async function processMarkdownRoute(state, nuxt, route, parsed, lastmod, options
       title,
       description,
       headings: flattenHeadings(headings),
+      keywords: keywords || [],
       updatedAt,
       markdown
     };
@@ -273,6 +314,92 @@ function detectSitemapPrerender(sitemapName = "sitemap.xml") {
     usePrerenderHook: shouldHookIntoPrerender && !prerenderSitemap
   };
 }
+async function createDatabaseDump(entries, errorRoutes, dbConfig) {
+  const Database = (await import('better-sqlite3')).default;
+  const dbPath = dbConfig.filename || ".data/ai-ready/pages.db";
+  await mkdir(dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS pages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      route TEXT UNIQUE NOT NULL,
+      route_key TEXT UNIQUE NOT NULL,
+      title TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '',
+      markdown TEXT NOT NULL DEFAULT '',
+      headings TEXT NOT NULL DEFAULT '[]',
+      keywords TEXT NOT NULL DEFAULT '[]',
+      updated_at TEXT NOT NULL,
+      indexed_at INTEGER NOT NULL,
+      is_error INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_pages_route ON pages(route);
+    CREATE INDEX IF NOT EXISTS idx_pages_is_error ON pages(is_error);
+    CREATE VIRTUAL TABLE IF NOT EXISTS pages_fts USING fts5(
+      route, title, description, markdown, headings, keywords,
+      content=pages, content_rowid=id
+    );
+    CREATE TRIGGER IF NOT EXISTS pages_ai AFTER INSERT ON pages BEGIN
+      INSERT INTO pages_fts(rowid, route, title, description, markdown, headings, keywords)
+      VALUES (new.id, new.route, new.title, new.description, new.markdown, new.headings, new.keywords);
+    END;
+    CREATE TRIGGER IF NOT EXISTS pages_ad AFTER DELETE ON pages BEGIN
+      INSERT INTO pages_fts(pages_fts, rowid, route, title, description, markdown, headings, keywords)
+      VALUES('delete', old.id, old.route, old.title, old.description, old.markdown, old.headings, old.keywords);
+    END;
+    CREATE TRIGGER IF NOT EXISTS pages_au AFTER UPDATE ON pages BEGIN
+      INSERT INTO pages_fts(pages_fts, rowid, route, title, description, markdown, headings, keywords)
+      VALUES('delete', old.id, old.route, old.title, old.description, old.markdown, old.headings, old.keywords);
+      INSERT INTO pages_fts(rowid, route, title, description, markdown, headings, keywords)
+      VALUES (new.id, new.route, new.title, new.description, new.markdown, new.headings, new.keywords);
+    END;
+  `);
+  const insertStmt = db.prepare(`
+    INSERT OR REPLACE INTO pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const normalizeRouteKey = (route) => route.replace(/^\//, "").replace(/\//g, ":") || "index";
+  const now = Date.now();
+  for (const entry of entries) {
+    insertStmt.run(
+      entry.route,
+      normalizeRouteKey(entry.route),
+      entry.title,
+      entry.description,
+      entry.markdown,
+      entry.headings,
+      JSON.stringify(entry.keywords),
+      entry.updatedAt,
+      now,
+      0
+    );
+  }
+  for (const route of errorRoutes) {
+    insertStmt.run(
+      route,
+      normalizeRouteKey(route),
+      "",
+      "",
+      "",
+      "[]",
+      "[]",
+      (/* @__PURE__ */ new Date()).toISOString(),
+      now,
+      1
+    );
+  }
+  const rows = db.prepare(`
+    SELECT route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error
+    FROM pages
+  `).all();
+  db.close();
+  const json = JSON.stringify(rows);
+  const encoder = new TextEncoder();
+  const stream = new Blob([encoder.encode(json)]).stream();
+  const compressed = stream.pipeThrough(new CompressionStream("gzip"));
+  const buffer = await new Response(compressed).arrayBuffer();
+  return Buffer.from(buffer).toString("base64");
+}
 async function prerenderRoute(nitro, route) {
   const start = Date.now();
   const encodedRoute = encodeURI(route);
@@ -282,7 +409,7 @@ async function prerenderRoute(nitro, route) {
     retry: nitro.options.prerender.retry,
     retryDelay: nitro.options.prerender.retryDelay
   });
-  const filePath = join(nitro.options.output.publicDir, route);
+  const filePath = join$1(nitro.options.output.publicDir, route);
   await mkdir(dirname(filePath), { recursive: true });
   const data = res._data;
   if (data === void 0)
@@ -298,8 +425,9 @@ async function prerenderRoute(nitro, route) {
 }
 function setupPrerenderHandler(pageDataPath, siteInfo, llmsTxtConfig) {
   const nuxt = useNuxt();
+  const dbConfig = refineDatabaseConfig({}, nuxt.options.rootDir);
   nuxt.hooks.hook("nitro:init", async (nitro) => {
-    const llmsFullTxtPath = join(nitro.options.output.publicDir, "llms-full.txt");
+    const llmsFullTxtPath = join$1(nitro.options.output.publicDir, "llms-full.txt");
     const state = createCrawlerState(pageDataPath, llmsFullTxtPath, siteInfo, llmsTxtConfig);
     let initPromise = null;
     nitro.hooks.hook("prerender:generate", async (route) => {
@@ -319,7 +447,7 @@ function setupPrerenderHandler(pageDataPath, siteInfo, llmsTxtConfig) {
         initPromise = initCrawler(state);
       await initPromise;
       const parsed = JSON.parse(route.contents || "{}");
-      const { markdown, title, description, headings, updatedAt: metaUpdatedAt } = parsed;
+      const { markdown, title, description, headings, keywords, updatedAt: metaUpdatedAt } = parsed;
       let updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       if (metaUpdatedAt) {
         const parsedDate = new Date(metaUpdatedAt);
@@ -339,6 +467,7 @@ function setupPrerenderHandler(pageDataPath, siteInfo, llmsTxtConfig) {
           title,
           description,
           headings: flattenHeadings(headings),
+          keywords: keywords || [],
           updatedAt,
           markdown
         };
@@ -361,24 +490,32 @@ function setupPrerenderHandler(pageDataPath, siteInfo, llmsTxtConfig) {
         }
         logger.debug(`Wrote ${state.errorRoutes.size} error routes to page data`);
       }
+      const publicDataDir = join$1(nitro.options.output.publicDir, "__ai-ready");
+      await mkdir(publicDataDir, { recursive: true });
       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");
+          const pages = entries.filter((e) => !e._error);
+          const errorRoutesList = entries.filter((e) => e._error).map((e) => e.route);
+          const jsonContent = JSON.stringify({
+            pages: pages.map((p) => ({
+              route: p.route,
+              title: p.title,
+              description: p.description,
+              headings: p.headings,
+              keywords: p.keywords || [],
+              updatedAt: p.updatedAt
+            })),
+            errorRoutes: errorRoutesList
+          });
+          const publicJsonPath = join$1(publicDataDir, "pages.json");
           await writeFile(publicJsonPath, jsonContent, "utf-8");
           logger.debug(`Wrote ${pages.length} pages to __ai-ready/pages.json`);
+          const dumpData = await createDatabaseDump(pages, errorRoutesList, dbConfig);
+          const dumpPath = join$1(publicDataDir, "pages.dump");
+          await writeFile(dumpPath, dumpData, "utf-8");
+          logger.debug(`Created database dump at __ai-ready/pages.dump (${(dumpData.length / 1024).toFixed(1)}kb compressed)`);
         }
       }
       const llmsStats = await prerenderRoute(nitro, "/llms.txt");
@@ -469,6 +606,11 @@ const module$1 = defineNuxtModule({
     hookNuxtSeoProLicense();
     nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
     nuxt.options.alias["#ai-ready"] = resolve("./runtime");
+    ({ resolver: createResolver(import.meta.url) });
+    const dbType = config.database?.type || "sqlite";
+    const adapterPath = await resolveDatabaseAdapter(dbType);
+    nuxt.options.alias["#ai-ready/adapter"] = adapterPath;
+    nuxt.options.nitro.alias["#ai-ready/adapter"] = adapterPath;
     if (!nuxt.options.mcp?.name) {
       nuxt.options.mcp = nuxt.options.mcp || {};
       nuxt.options.mcp.name = useSiteConfig().name;
@@ -489,13 +631,14 @@ const module$1 = defineNuxtModule({
     addTypeTemplate({
       filename: "types/nuxt-ai-ready.d.ts",
       getContents: () => `// Generated by nuxt-ai-ready
-import type { MarkdownContext } from 'nuxt-ai-ready'
+import type { MarkdownContext, PageIndexedContext } from 'nuxt-ai-ready'
 import type { HTMLToMarkdownOptions } from 'mdream'
 
 declare module 'nitropack/types' {
   interface NitroRuntimeHooks {
     'ai-ready:markdown': (context: MarkdownContext) => void | Promise<void>
     'ai-ready:mdreamConfig': (config: HTMLToMarkdownOptions) => void | Promise<void>
+    'ai-ready:page:indexed': (context: PageIndexedContext) => void | Promise<void>
   }
 }
 
@@ -506,6 +649,7 @@ declare module '#ai-ready-virtual/read-page-data.mjs' {
       title: string
       description: string
       headings: string
+      keywords: string[]
       updatedAt: string
       markdown: string
     }>
@@ -517,6 +661,12 @@ declare module '#ai-ready-virtual/page-data.mjs' {
   export const pages: never[]
 }
 
+declare module '#ai-ready/adapter' {
+  import type { Connector } from 'db0'
+  const connector: (config: unknown) => Connector
+  export default connector
+}
+
 export {}
 `
     }, { nitro: true });
@@ -570,8 +720,8 @@ export {}
     await nuxt.callHook("ai-ready:llms-txt", llmsTxtPayload);
     mergedLlmsTxt.sections = llmsTxtPayload.sections;
     mergedLlmsTxt.notes = llmsTxtPayload.notes.length > 0 ? llmsTxtPayload.notes : void 0;
-    const prerenderCacheDir = join(nuxt.options.rootDir, "node_modules/.cache/nuxt-seo/ai-ready/routes");
-    const pageDataPath = join(nuxt.options.buildDir, ".data/ai-ready/page-data.jsonl");
+    const prerenderCacheDir = join$1(nuxt.options.rootDir, "node_modules/.cache/nuxt-seo/ai-ready/routes");
+    const pageDataPath = join$1(nuxt.options.buildDir, ".data/ai-ready/page-data.jsonl");
     nuxt.hooks.hook("nitro:config", (nitroConfig) => {
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.asyncContext = true;
@@ -594,6 +744,7 @@ export async function readPageDataFromFilesystem() {
       nitroConfig.virtual["#ai-ready-virtual/page-data.mjs"] = `export const pages = []
 export const errorRoutes = []`;
     });
+    const database = refineDatabaseConfig(config.database || {}, nuxt.options.rootDir);
     nuxt.options.runtimeConfig["nuxt-ai-ready"] = {
       version: version || "0.0.0",
       debug: config.debug || false,
@@ -604,8 +755,13 @@ export const errorRoutes = []`;
       }),
       llmsTxt: mergedLlmsTxt,
       cacheMaxAgeSeconds: config.cacheMaxAgeSeconds ?? 600,
-      prerenderCacheDir
+      prerenderCacheDir,
+      ttl: config.ttl ?? 0,
+      database
     };
+    nuxt.options.nitro.plugins = nuxt.options.nitro.plugins || [];
+    nuxt.options.nitro.plugins.push(resolve("./runtime/server/plugins/db-restore"));
+    nuxt.options.nitro.plugins.push(resolve("./runtime/server/plugins/page-indexer"));
     addServerHandler({
       middleware: true,
       handler: resolve("./runtime/server/middleware/markdown.prerender")
@@ -649,7 +805,7 @@ export const errorRoutes = []`;
     nuxt.options.nitro.routeRules["/llms-full.txt"] = { headers: { "Content-Type": "text/plain; charset=utf-8" } };
     nuxt.hooks.hook("nitro:build:before", (nitro) => {
       nitro.hooks.hook("compiled", async () => {
-        const headersPath = join(nitro.options.output.publicDir, "_headers");
+        const headersPath = join$1(nitro.options.output.publicDir, "_headers");
         const exists = await access(headersPath).then(() => true).catch(() => false);
         if (exists) {
           await appendFile(headersPath, `

package/dist/runtime/index.d.ts

@@ -0,0 +1,9 @@
+export { indexPage, indexPageByRoute } from './server/utils/indexPage.js';
+export type { IndexPageOptions, IndexPageResult } from './server/utils/indexPage.js';
+export { getPages, getPagesList, getErrorRoutes } from './server/utils/pageData.js';
+export type { PageEntry, PageData, PageListItem } from './server/utils/pageData.js';
+export { useDatabase } from './server/db/index.js';
+export type { DatabaseAdapter } from './server/db/schema.js';
+export { searchPages, getAllPages, getPage, getPageWithMarkdown, upsertPage, getPageCount } from './server/db/queries.js';
+export type { SearchResult, PageRow } from './server/db/queries.js';
+export type { MarkdownContext, PageIndexedContext, PageMarkdownContext, } from './types.js';

package/dist/runtime/index.js

@@ -0,0 +1,4 @@
+export { indexPage, indexPageByRoute } from "./server/utils/indexPage.js";
+export { getPages, getPagesList, getErrorRoutes } from "./server/utils/pageData.js";
+export { useDatabase } from "./server/db/index.js";
+export { searchPages, getAllPages, getPage, getPageWithMarkdown, upsertPage, getPageCount } from "./server/db/queries.js";

package/dist/runtime/mcp.d.ts

@@ -0,0 +1,32 @@
+export declare const tools: readonly [{
+    name: string;
+    description: string;
+    inputSchema: {};
+    cache: "1h";
+    handler(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+}, import("@nuxtjs/mcp-toolkit").McpToolDefinition<Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>, Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>>];
+export declare const resources: readonly [{
+    uri: string;
+    name: string;
+    description: string;
+    metadata: {
+        mimeType: string;
+    };
+    cache: "1h";
+    handler(uri: URL): Promise<{
+        contents: {
+            uri: string;
+            mimeType: string;
+            text: string;
+        }[];
+    }>;
+}];

package/dist/runtime/mcp.js

@@ -0,0 +1,5 @@
+import pages from "./server/mcp/resources/pages.js";
+import listPages from "./server/mcp/tools/list-pages.js";
+import searchPages from "./server/mcp/tools/search-pages.js";
+export const tools = [listPages, searchPages];
+export const resources = [pages];

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

@@ -0,0 +1,29 @@
+import type { DatabaseAdapter } from './schema.js';
+export interface DumpRow {
+    route: string;
+    route_key: string;
+    title: string;
+    description: string;
+    markdown: string;
+    headings: string;
+    keywords: string;
+    updated_at: string;
+    indexed_at: number;
+    is_error: number;
+}
+/**
+ * Export all pages as JSON for dump
+ */
+export declare function exportDump(db: DatabaseAdapter): Promise<DumpRow[]>;
+/**
+ * Compress dump data to base64 gzip
+ */
+export declare function compressDump(data: DumpRow[]): Promise<string>;
+/**
+ * Decompress dump from base64 gzip
+ */
+export declare function decompressDump(base64: string): Promise<DumpRow[]>;
+/**
+ * Import dump into database
+ */
+export declare function importDump(db: DatabaseAdapter, rows: DumpRow[]): Promise<void>;

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

@@ -0,0 +1,29 @@
+export async function exportDump(db) {
+  return db.all(`
+    SELECT route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error
+    FROM pages
+  `);
+}
+export async function compressDump(data) {
+  const json = JSON.stringify(data);
+  const encoder = new TextEncoder();
+  const stream = new Blob([encoder.encode(json)]).stream();
+  const compressed = stream.pipeThrough(new CompressionStream("gzip"));
+  const buffer = await new Response(compressed).arrayBuffer();
+  return Buffer.from(buffer).toString("base64");
+}
+export async function decompressDump(base64) {
+  const buffer = Buffer.from(base64, "base64");
+  const stream = new Blob([buffer]).stream();
+  const decompressed = stream.pipeThrough(new DecompressionStream("gzip"));
+  const text = await new Response(decompressed).text();
+  return JSON.parse(text);
+}
+export async function importDump(db, rows) {
+  for (const row of rows) {
+    await db.exec(`
+      INSERT OR REPLACE INTO pages (route, route_key, title, description, markdown, headings, keywords, updated_at, indexed_at, is_error)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [row.route, row.route_key, row.title, row.description, row.markdown, row.headings, row.keywords, row.updated_at, row.indexed_at, row.is_error]);
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { H3Event } from 'h3';
+import type { DatabaseAdapter } from './schema.js';
+/**
+ * Get the database adapter instance
+ * Initializes the database on first call
+ */
+export declare function useDatabase(event?: H3Event): Promise<DatabaseAdapter>;
+/**
+ * Reset database connection (for testing)
+ */
+export declare function _resetDatabase(): void;
+export type { DatabaseAdapter } from './schema.js';

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

@@ -0,0 +1,56 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "pathe";
+import { initSchema } from "./schema.js";
+import adapter from "#ai-ready/adapter";
+let _db = null;
+let _initPromise = null;
+export function useDatabase(event) {
+  if (!_initPromise) {
+    _initPromise = initDatabase(event);
+  }
+  return _initPromise;
+}
+async function initDatabase(event) {
+  const config = useRuntimeConfig()["nuxt-ai-ready"];
+  if (config.database.type === "d1") {
+    const binding = event?.context?.cloudflare?.env?.[config.database.bindingName || "AI_READY_DB"];
+    if (!binding) {
+      throw new Error(`D1 binding '${config.database.bindingName || "AI_READY_DB"}' not found in event context`);
+    }
+    _db = adapter({ binding });
+  } else if (config.database.type === "libsql") {
+    _db = adapter({
+      url: config.database.url,
+      authToken: config.database.authToken
+    });
+  } else {
+    const dbPath = config.database.filename || ".data/ai-ready/pages.db";
+    await mkdir(dirname(dbPath), { recursive: true });
+    _db = adapter({ path: dbPath });
+  }
+  if (!_db) {
+    throw new Error("Failed to initialize database connector");
+  }
+  const dbAdapter = createAdapter(_db);
+  await initSchema(dbAdapter);
+  return dbAdapter;
+}
+function createAdapter(db) {
+  return {
+    all: async (sql, params = []) => {
+      const result = await db.prepare(sql).all(...params);
+      return result || [];
+    },
+    first: async (sql, params = []) => {
+      return db.prepare(sql).get(...params);
+    },
+    exec: async (sql, params = []) => {
+      await db.prepare(sql).run(...params);
+    }
+  };
+}
+export function _resetDatabase() {
+  _db = null;
+  _initPromise = null;
+}

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

@@ -0,0 +1,84 @@
+import type { DatabaseAdapter } from './schema.js';
+export interface PageRow {
+    id: number;
+    route: string;
+    route_key: string;
+    title: string;
+    description: string;
+    markdown: string;
+    headings: string;
+    keywords: string;
+    updated_at: string;
+    indexed_at: number;
+    is_error: number;
+}
+export interface PageEntry {
+    route: string;
+    title: string;
+    description: string;
+    headings: string;
+    keywords: string[];
+    updatedAt: string;
+}
+export interface PageData extends PageEntry {
+    markdown: string;
+}
+export interface SearchResult {
+    route: string;
+    title: string;
+    description: string;
+    score: number;
+}
+/**
+ * Get all non-error pages
+ */
+export declare function getAllPages(db: DatabaseAdapter): Promise<PageEntry[]>;
+/**
+ * Get a single page by route
+ */
+export declare function getPage(db: DatabaseAdapter, route: string): Promise<PageEntry | undefined>;
+/**
+ * Get a page with markdown content
+ */
+export declare function getPageWithMarkdown(db: DatabaseAdapter, route: string): Promise<PageData | undefined>;
+/**
+ * Full-text search using FTS5
+ * @param query Search query string
+ * @param opts Search options
+ */
+export declare function searchPages(db: DatabaseAdapter, query: string, opts?: {
+    limit?: number;
+}): Promise<SearchResult[]>;
+/**
+ * Insert or update a page
+ */
+export declare function upsertPage(db: DatabaseAdapter, page: {
+    route: string;
+    title: string;
+    description: string;
+    markdown: string;
+    headings: string;
+    keywords: string[];
+    updatedAt: string;
+    isError?: boolean;
+}): Promise<void>;
+/**
+ * Get all error routes
+ */
+export declare function getErrorRoutes(db: DatabaseAdapter): Promise<string[]>;
+/**
+ * Check if a page is fresh (within TTL)
+ */
+export declare function isPageFresh(db: DatabaseAdapter, route: string, ttlSeconds: number): Promise<boolean>;
+/**
+ * Delete a page by route
+ */
+export declare function deletePage(db: DatabaseAdapter, route: string): Promise<void>;
+/**
+ * Get page count
+ */
+export declare function getPageCount(db: DatabaseAdapter): Promise<number>;
+/**
+ * Check if database has any pages
+ */
+export declare function hasPages(db: DatabaseAdapter): Promise<boolean>;