nuxt-ai-ready 0.7.1 → 0.7.2

package/dist/module.json

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

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

@@ -162,3 +162,49 @@ export interface IndexNowStats {
  * Get IndexNow stats
  */
 export declare function getIndexNowStats(event: H3Event | undefined): Promise<IndexNowStats>;
+export interface CronRunRow {
+    id: number;
+    started_at: number;
+    finished_at: number | null;
+    duration_ms: number | null;
+    pages_indexed: number;
+    pages_remaining: number;
+    indexnow_submitted: number;
+    indexnow_remaining: number;
+    errors: string;
+    status: 'running' | 'success' | 'partial' | 'error';
+}
+export interface CronRun {
+    id: number;
+    startedAt: number;
+    finishedAt: number | null;
+    durationMs: number | null;
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+    status: 'running' | 'success' | 'partial' | 'error';
+}
+/**
+ * Start a cron run and return its ID
+ */
+export declare function startCronRun(event: H3Event | undefined): Promise<number | null>;
+/**
+ * Complete a cron run with results
+ */
+export declare function completeCronRun(event: H3Event | undefined, runId: number, result: {
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+}): Promise<void>;
+/**
+ * Get recent cron runs
+ */
+export declare function getRecentCronRuns(event: H3Event | undefined, limit?: number): Promise<CronRun[]>;
+/**
+ * Clean up old cron runs (keep last N)
+ */
+export declare function cleanupOldCronRuns(event: H3Event | undefined, keepCount?: number): Promise<number>;

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

@@ -374,3 +374,76 @@ export async function getIndexNowStats(event) {
     lastError: stats.indexnow_last_error || null
   };
 }
+function rowToCronRun(row) {
+  return {
+    id: row.id,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    durationMs: row.duration_ms,
+    pagesIndexed: row.pages_indexed,
+    pagesRemaining: row.pages_remaining,
+    indexNowSubmitted: row.indexnow_submitted,
+    indexNowRemaining: row.indexnow_remaining,
+    errors: JSON.parse(row.errors || "[]"),
+    status: row.status
+  };
+}
+export async function startCronRun(event) {
+  const db = await getDb(event);
+  if (!db)
+    return null;
+  const now = Date.now();
+  await db.exec(
+    "INSERT INTO ai_ready_cron_runs (started_at, status) VALUES (?, ?)",
+    [now, "running"]
+  );
+  const row = await db.first("SELECT last_insert_rowid() as id");
+  return row?.id || null;
+}
+export async function completeCronRun(event, runId, result) {
+  const db = await getDb(event);
+  if (!db)
+    return;
+  const now = Date.now();
+  const row = await db.first("SELECT started_at FROM ai_ready_cron_runs WHERE id = ?", [runId]);
+  const durationMs = row ? now - row.started_at : null;
+  const status = result.errors.length > 0 ? result.pagesIndexed > 0 ? "partial" : "error" : "success";
+  await db.exec(`
+    UPDATE ai_ready_cron_runs SET
+      finished_at = ?,
+      duration_ms = ?,
+      pages_indexed = ?,
+      pages_remaining = ?,
+      indexnow_submitted = ?,
+      indexnow_remaining = ?,
+      errors = ?,
+      status = ?
+    WHERE id = ?
+  `, [now, durationMs, result.pagesIndexed, result.pagesRemaining, result.indexNowSubmitted, result.indexNowRemaining, JSON.stringify(result.errors), status, runId]);
+}
+export async function getRecentCronRuns(event, limit = 10) {
+  const db = await getDb(event);
+  if (!db)
+    return [];
+  const rows = await db.all(
+    "SELECT * FROM ai_ready_cron_runs ORDER BY started_at DESC LIMIT ?",
+    [limit]
+  );
+  return rows.map(rowToCronRun);
+}
+export async function cleanupOldCronRuns(event, keepCount = 50) {
+  const db = await getDb(event);
+  if (!db)
+    return 0;
+  const countRow = await db.first("SELECT COUNT(*) as count FROM ai_ready_cron_runs");
+  const total = countRow?.count || 0;
+  if (total <= keepCount)
+    return 0;
+  const deleteCount = total - keepCount;
+  await db.exec(`
+    DELETE FROM ai_ready_cron_runs WHERE id IN (
+      SELECT id FROM ai_ready_cron_runs ORDER BY started_at ASC LIMIT ?
+    )
+  `, [deleteCount]);
+  return deleteCount;
+}

package/dist/runtime/server/db/schema-sql.d.ts

@@ -1,3 +1,3 @@
-export declare const SCHEMA_VERSION = "v1.6.0";
+export declare const SCHEMA_VERSION = "v1.7.0";
 export declare const DROP_TABLES_SQL: string[];
 export declare const ALL_SCHEMA_SQL: string[];

package/dist/runtime/server/db/schema-sql.js

@@ -1,4 +1,4 @@
-export const SCHEMA_VERSION = "v1.6.0";
+export const SCHEMA_VERSION = "v1.7.0";
 const PAGES_TABLE_SQL = `
 CREATE TABLE IF NOT EXISTS ai_ready_pages (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -54,9 +54,24 @@ CREATE TABLE IF NOT EXISTS _ai_ready_info (
   checksum TEXT,
   ready INTEGER DEFAULT 0
 )`;
+const CRON_RUNS_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS ai_ready_cron_runs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  started_at INTEGER NOT NULL,
+  finished_at INTEGER,
+  duration_ms INTEGER,
+  pages_indexed INTEGER DEFAULT 0,
+  pages_remaining INTEGER DEFAULT 0,
+  indexnow_submitted INTEGER DEFAULT 0,
+  indexnow_remaining INTEGER DEFAULT 0,
+  errors TEXT DEFAULT '[]',
+  status TEXT DEFAULT 'running'
+)`;
+const CRON_RUNS_INDEX_SQL = "CREATE INDEX IF NOT EXISTS idx_ai_ready_cron_runs_started ON ai_ready_cron_runs(started_at DESC)";
 export const DROP_TABLES_SQL = [
   "DROP TABLE IF EXISTS ai_ready_pages_fts",
   "DROP TABLE IF EXISTS ai_ready_pages",
+  "DROP TABLE IF EXISTS ai_ready_cron_runs",
   "DROP TABLE IF EXISTS _ai_ready_info",
   // Legacy unprefixed tables (migration from v1.0.0)
   "DROP TABLE IF EXISTS pages_fts",
@@ -67,5 +82,7 @@ export const ALL_SCHEMA_SQL = [
   ...PAGES_INDEXES_SQL,
   FTS_TABLE_SQL,
   ...FTS_TRIGGERS_SQL,
-  INFO_TABLE_SQL
+  INFO_TABLE_SQL,
+  CRON_RUNS_TABLE_SQL,
+  CRON_RUNS_INDEX_SQL
 ];

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

@@ -13,7 +13,8 @@ export default defineEventHandler(async (event) => {
   const { path, isExplicit } = renderInfo;
   const config = useRuntimeConfig(event)["nuxt-ai-ready"];
   const response = await event.fetch(path, {
-    headers: { [INTERNAL_HEADER]: "1" }
+    headers: { [INTERNAL_HEADER]: "1" },
+    redirect: "manual"
   }).catch((e) => {
     logger.error(`Failed to fetch HTML for ${path}`, e);
     return null;
@@ -28,6 +29,17 @@ export default defineEventHandler(async (event) => {
     }
     return;
   }
+  if (response.status >= 300 && response.status < 400) {
+    const location = response.headers.get("location");
+    if (location) {
+      const redirectTarget = location.endsWith("/") ? `${location.slice(0, -1)}.md` : `${location}.md`;
+      setHeader(event, "location", redirectTarget);
+      return createError({
+        statusCode: response.status,
+        statusMessage: response.statusText
+      });
+    }
+  }
   if (!response.ok) {
     if (isExplicit) {
       return createError({

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

@@ -1,3 +1,15 @@
+interface CronRunInfo {
+    id: number;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number | null;
+    status: string;
+    pagesIndexed: number;
+    pagesRemaining: number;
+    indexNowSubmitted: number;
+    indexNowRemaining: number;
+    errors: string[];
+}
 interface DebugInfo {
     version: string;
     environment: {
@@ -10,6 +22,19 @@ interface DebugInfo {
         cacheMaxAgeSeconds: number;
         mdreamOptions: unknown;
     };
+    runtimeSync?: {
+        total: number;
+        indexed: number;
+        pending: number;
+        sitemapSeededAt: string | null;
+    };
+    indexNow?: {
+        pending: number;
+        totalSubmitted: number;
+        lastSubmittedAt: string | null;
+        lastError: string | null;
+    };
+    cronRuns?: CronRunInfo[];
     pageData: {
         source: string;
         pageCount: number;

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

@@ -1,6 +1,6 @@
 import { createError, eventHandler, setHeader } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-import { queryPages } from "../db/queries.js";
+import { countPages, countPagesNeedingIndexNowSync, getIndexNowStats, getRecentCronRuns, getSitemapSeededAt, queryPages } from "../db/queries.js";
 export default eventHandler(async (event) => {
   const runtimeConfig = useRuntimeConfig(event)["nuxt-ai-ready"];
   if (!runtimeConfig.debug) {
@@ -90,6 +90,47 @@ export default eventHandler(async (event) => {
     issues.push("Prerender mode but no pages found");
     suggestions.push("Check if pages.db exists in .data/ai-ready/");
   }
+  let runtimeSyncInfo;
+  let indexNowInfo;
+  let cronRunsInfo;
+  if (!isDev && !isPrerender) {
+    const [total, pending, sitemapSeededAt, cronRuns] = await Promise.all([
+      countPages(event),
+      countPages(event, { where: { pending: true } }),
+      getSitemapSeededAt(event),
+      getRecentCronRuns(event, 20)
+    ]);
+    runtimeSyncInfo = {
+      total,
+      indexed: total - pending,
+      pending,
+      sitemapSeededAt: sitemapSeededAt ? new Date(sitemapSeededAt).toISOString() : null
+    };
+    cronRunsInfo = cronRuns.map((run) => ({
+      id: run.id,
+      startedAt: new Date(run.startedAt).toISOString(),
+      finishedAt: run.finishedAt ? new Date(run.finishedAt).toISOString() : null,
+      durationMs: run.durationMs,
+      status: run.status,
+      pagesIndexed: run.pagesIndexed,
+      pagesRemaining: run.pagesRemaining,
+      indexNowSubmitted: run.indexNowSubmitted,
+      indexNowRemaining: run.indexNowRemaining,
+      errors: run.errors
+    }));
+    if (runtimeConfig.indexNowKey) {
+      const [indexNowPending, indexNowStats] = await Promise.all([
+        countPagesNeedingIndexNowSync(event),
+        getIndexNowStats(event)
+      ]);
+      indexNowInfo = {
+        pending: indexNowPending,
+        totalSubmitted: indexNowStats.totalSubmitted,
+        lastSubmittedAt: indexNowStats.lastSubmittedAt ? new Date(indexNowStats.lastSubmittedAt).toISOString() : null,
+        lastError: indexNowStats.lastError
+      };
+    }
+  }
   const debugInfo = {
     version: runtimeConfig.version || "unknown",
     environment: {
@@ -102,6 +143,9 @@ export default eventHandler(async (event) => {
       cacheMaxAgeSeconds: runtimeConfig.cacheMaxAgeSeconds,
       mdreamOptions: runtimeConfig.mdreamOptions
     },
+    runtimeSync: runtimeSyncInfo,
+    indexNow: indexNowInfo,
+    cronRuns: cronRunsInfo,
     pageData: {
       source,
       pageCount: pages.length,

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

@@ -1,5 +1,6 @@
 import type { H3Event } from 'h3';
 export interface CronResult {
+    runId?: number | null;
     index?: {
         indexed: number;
         remaining: number;

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

@@ -1,9 +1,13 @@
 import { useRuntimeConfig } from "nitropack/runtime";
+import { cleanupOldCronRuns, completeCronRun, startCronRun } from "../db/queries.js";
 import { batchIndexPages } from "./batchIndex.js";
 import { syncToIndexNow } from "./indexnow.js";
 export async function runCron(event, options) {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const results = {};
+  const allErrors = [];
+  const runId = await startCronRun(event);
+  results.runId = runId;
   if (config.runtimeSync.enabled) {
     const limit = options?.batchSize ?? config.runtimeSync.batchSize;
     const indexResult = await batchIndexPages(event, {
@@ -16,6 +20,9 @@ export async function runCron(event, options) {
       errors: indexResult.errors.length > 0 ? indexResult.errors : void 0,
       complete: indexResult.complete
     };
+    if (indexResult.errors.length > 0) {
+      allErrors.push(...indexResult.errors);
+    }
   }
   if (config.indexNowKey) {
     const indexNowResult = await syncToIndexNow(event, 100).catch((err) => {
@@ -27,6 +34,19 @@ export async function runCron(event, options) {
       remaining: indexNowResult.remaining,
       error: indexNowResult.error
     };
+    if (indexNowResult.error) {
+      allErrors.push(`IndexNow: ${indexNowResult.error}`);
+    }
+  }
+  if (runId) {
+    await completeCronRun(event, runId, {
+      pagesIndexed: results.index?.indexed || 0,
+      pagesRemaining: results.index?.remaining || 0,
+      indexNowSubmitted: results.indexNow?.submitted || 0,
+      indexNowRemaining: results.indexNow?.remaining || 0,
+      errors: allErrors
+    });
+    await cleanupOldCronRuns(event, 50);
   }
   return results;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",