@sonicjs-cms/core 2.4.0 → 2.6.0

package/dist/index.js

@@ -1,17 +1,19 @@
-import { PluginBuilder, api_default, api_media_default, api_system_default, admin_api_default, router, adminCollectionsRoutes, adminSettingsRoutes, admin_content_default, adminMediaRoutes, adminPluginRoutes, adminLogsRoutes, userRoutes, auth_default, test_cleanup_default, checkAdminUserExists } from './chunk-FT6NBHNX.js';
-export { ROUTES_INFO, admin_api_default as adminApiRoutes, adminCheckboxRoutes, admin_code_examples_default as adminCodeExamplesRoutes, adminCollectionsRoutes, admin_content_default as adminContentRoutes, router as adminDashboardRoutes, adminDesignRoutes, adminLogsRoutes, adminMediaRoutes, adminPluginRoutes, adminSettingsRoutes, admin_testimonials_default as adminTestimonialsRoutes, userRoutes as adminUsersRoutes, api_content_crud_default as apiContentCrudRoutes, api_media_default as apiMediaRoutes, api_default as apiRoutes, api_system_default as apiSystemRoutes, auth_default as authRoutes } from './chunk-FT6NBHNX.js';
+import { api_default, api_media_default, api_system_default, admin_api_default, router, adminCollectionsRoutes, adminSettingsRoutes, admin_content_default, adminMediaRoutes, adminPluginRoutes, adminLogsRoutes, userRoutes, auth_default, test_cleanup_default } from './chunk-F6GZURXJ.js';
+export { ROUTES_INFO, admin_api_default as adminApiRoutes, adminCheckboxRoutes, admin_code_examples_default as adminCodeExamplesRoutes, adminCollectionsRoutes, admin_content_default as adminContentRoutes, router as adminDashboardRoutes, adminDesignRoutes, adminLogsRoutes, adminMediaRoutes, adminPluginRoutes, adminSettingsRoutes, admin_testimonials_default as adminTestimonialsRoutes, userRoutes as adminUsersRoutes, api_content_crud_default as apiContentCrudRoutes, api_media_default as apiMediaRoutes, api_default as apiRoutes, api_system_default as apiSystemRoutes, auth_default as authRoutes } from './chunk-F6GZURXJ.js';
 import { schema_exports } from './chunk-3YNNVSMC.js';
 export { Logger, apiTokens, collections, content, contentVersions, getLogger, initLogger, insertCollectionSchema, insertContentSchema, insertLogConfigSchema, insertMediaSchema, insertPluginActivityLogSchema, insertPluginAssetSchema, insertPluginHookSchema, insertPluginRouteSchema, insertPluginSchema, insertSystemLogSchema, insertUserSchema, insertWorkflowHistorySchema, logConfig, media, pluginActivityLog, pluginAssets, pluginHooks, pluginRoutes, plugins, selectCollectionSchema, selectContentSchema, selectLogConfigSchema, selectMediaSchema, selectPluginActivityLogSchema, selectPluginAssetSchema, selectPluginHookSchema, selectPluginRouteSchema, selectPluginSchema, selectSystemLogSchema, selectUserSchema, selectWorkflowHistorySchema, systemLogs, users, workflowHistory } from './chunk-3YNNVSMC.js';
-import { AuthManager, metricsMiddleware, bootstrapMiddleware, requireAuth } from './chunk-DXM575E2.js';
-export { AuthManager, PermissionManager, bootstrapMiddleware, cacheHeaders, compressionMiddleware, detailedLoggingMiddleware, getActivePlugins, isPluginActive, logActivity, loggingMiddleware, optionalAuth, performanceLoggingMiddleware, requireActivePlugin, requireActivePlugins, requireAnyPermission, requireAuth, requirePermission, requireRole, securityHeaders, securityLoggingMiddleware } from './chunk-DXM575E2.js';
-export { PluginBootstrapService, PluginService as PluginServiceClass, cleanupRemovedCollections, fullCollectionSync, getAvailableCollectionNames, getManagedCollections, isCollectionManaged, loadCollectionConfig, loadCollectionConfigs, registerCollections, syncCollection, syncCollections, validateCollectionConfig } from './chunk-SGAG6FD3.js';
-export { MigrationService } from './chunk-D2NLCPO2.js';
-export { renderFilterBar } from './chunk-AVPUX57O.js';
-import { init_admin_layout_catalyst_template, renderAdminLayout, adminLayoutV2, renderAdminLayoutCatalyst } from './chunk-V5LBQN3I.js';
-export { getConfirmationDialogScript, renderAlert, renderConfirmationDialog, renderForm, renderFormField, renderPagination, renderTable } from './chunk-V5LBQN3I.js';
-export { HookSystemImpl, HookUtils, PluginManager as PluginManagerClass, PluginRegistryImpl, PluginValidator as PluginValidatorClass, ScopedHookSystem as ScopedHookSystemClass } from './chunk-CPXAVWCU.js';
-import { package_default, getCoreVersion } from './chunk-VNCYCH3H.js';
-export { QueryFilterBuilder, SONICJS_VERSION, TemplateRenderer, buildQuery, escapeHtml, getCoreVersion, renderTemplate, sanitizeInput, sanitizeObject, templateRenderer } from './chunk-VNCYCH3H.js';
+import { requireAuth, AuthManager, metricsMiddleware, bootstrapMiddleware } from './chunk-EYWR6UA2.js';
+export { AuthManager, PermissionManager, bootstrapMiddleware, cacheHeaders, compressionMiddleware, detailedLoggingMiddleware, getActivePlugins, isPluginActive, logActivity, loggingMiddleware, optionalAuth, performanceLoggingMiddleware, requireActivePlugin, requireActivePlugins, requireAnyPermission, requireAuth, requirePermission, requireRole, securityHeaders, securityLoggingMiddleware } from './chunk-EYWR6UA2.js';
+export { PluginBootstrapService, PluginService as PluginServiceClass, cleanupRemovedCollections, fullCollectionSync, getAvailableCollectionNames, getManagedCollections, isCollectionManaged, loadCollectionConfig, loadCollectionConfigs, registerCollections, syncCollection, syncCollections, validateCollectionConfig } from './chunk-YFJJU26H.js';
+export { MigrationService } from './chunk-EVZOVYLO.js';
+export { renderFilterBar } from './chunk-KAOWRIFD.js';
+import { init_admin_layout_catalyst_template, renderAdminLayout, adminLayoutV2, renderAdminLayoutCatalyst } from './chunk-KA2PDJNB.js';
+export { getConfirmationDialogScript, renderAlert, renderConfirmationDialog, renderForm, renderFormField, renderPagination, renderTable } from './chunk-KA2PDJNB.js';
+export { HookSystemImpl, HookUtils, PluginManager as PluginManagerClass, PluginRegistryImpl, PluginValidator as PluginValidatorClass, ScopedHookSystem as ScopedHookSystemClass } from './chunk-F332TENF.js';
+import { PluginBuilder } from './chunk-CLIH2T74.js';
+export { PluginBuilder, PluginHelpers } from './chunk-CLIH2T74.js';
+import { package_default, getCoreVersion } from './chunk-7DL5SPPX.js';
+export { QueryFilterBuilder, SONICJS_VERSION, TemplateRenderer, buildQuery, escapeHtml, getCoreVersion, renderTemplate, sanitizeInput, sanitizeObject, templateRenderer } from './chunk-7DL5SPPX.js';
 import './chunk-X7ZAEI5S.js';
 export { metricsTracker } from './chunk-FICTAGD4.js';
 export { HOOKS } from './chunk-LOUJRBXV.js';
@@ -22,31 +24,6 @@ import { setCookie } from 'hono/cookie';
 import { z } from 'zod';
 import { drizzle } from 'drizzle-orm/d1';
 
-// src/middleware/admin-setup.ts
-function adminSetupMiddleware() {
-  return async (c, next) => {
-    const path = new URL(c.req.url).pathname;
-    if (path.startsWith("/auth/")) {
-      return next();
-    }
-    if (path.match(/\.(js|css|ico|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/)) {
-      return next();
-    }
-    if (path === "/health") {
-      return next();
-    }
-    if (path.startsWith("/api/")) {
-      return next();
-    }
-    const db = c.env.DB;
-    const adminExists = await checkAdminUserExists(db);
-    if (!adminExists) {
-      return c.redirect("/auth/register?setup=true");
-    }
-    return next();
-  };
-}
-
 // src/plugins/core-plugins/database-tools-plugin/services/database-service.ts
 var DatabaseToolsService = class {
   constructor(db) {
@@ -2230,8 +2207,8 @@ function createOTPLoginPlugin() {
     requiresAuth: false,
     priority: 100
   });
-  const adminRoutes = new Hono();
-  adminRoutes.get("/settings", async (c) => {
+  const adminRoutes2 = new Hono();
+  adminRoutes2.get("/settings", async (c) => {
     const user = c.get("user");
     const contentHTML = await html`
       <div class="p-8">
@@ -2411,7 +2388,7 @@ function createOTPLoginPlugin() {
       })
     );
   });
-  builder.addRoute("/admin/plugins/otp-login", adminRoutes, {
+  builder.addRoute("/admin/plugins/otp-login", adminRoutes2, {
     description: "OTP login admin interface",
     requiresAuth: true,
     priority: 85
@@ -2432,6 +2409,1840 @@ function createOTPLoginPlugin() {
   return builder.build();
 }
 var otpLoginPlugin = createOTPLoginPlugin();
+
+// src/plugins/core-plugins/ai-search-plugin/services/embedding.service.ts
+var EmbeddingService = class {
+  constructor(ai) {
+    this.ai = ai;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async generateEmbedding(text) {
+    try {
+      const response = await this.ai.run("@cf/baai/bge-base-en-v1.5", {
+        text: this.preprocessText(text)
+      });
+      if (response.data && response.data.length > 0) {
+        return response.data[0];
+      }
+      throw new Error("No embedding data returned");
+    } catch (error) {
+      console.error("[EmbeddingService] Error generating embedding:", error);
+      throw error;
+    }
+  }
+  /**
+   * Generate embeddings for multiple texts (batch processing)
+   */
+  async generateBatch(texts) {
+    try {
+      const batchSize = 10;
+      const batches = [];
+      for (let i = 0; i < texts.length; i += batchSize) {
+        batches.push(texts.slice(i, i + batchSize));
+      }
+      const allEmbeddings = [];
+      for (const batch of batches) {
+        const batchEmbeddings = await Promise.all(
+          batch.map((text) => this.generateEmbedding(text))
+        );
+        allEmbeddings.push(...batchEmbeddings);
+      }
+      return allEmbeddings;
+    } catch (error) {
+      console.error("[EmbeddingService] Error generating batch embeddings:", error);
+      throw error;
+    }
+  }
+  /**
+   * Preprocess text before generating embedding
+   * - Trim whitespace
+   * - Limit length to avoid token limits
+   * - Remove special characters that might cause issues
+   */
+  preprocessText(text) {
+    if (!text) return "";
+    let processed = text.trim().replace(/\s+/g, " ");
+    if (processed.length > 8e3) {
+      processed = processed.substring(0, 8e3);
+    }
+    return processed;
+  }
+  /**
+   * Calculate cosine similarity between two embeddings
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Embeddings must have same dimensions");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      const aVal = a[i] ?? 0;
+      const bVal = b[i] ?? 0;
+      dotProduct += aVal * bVal;
+      normA += aVal * aVal;
+      normB += bVal * bVal;
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/chunking.service.ts
+var ChunkingService = class {
+  // Default chunk size (in approximate tokens)
+  CHUNK_SIZE = 500;
+  CHUNK_OVERLAP = 50;
+  /**
+   * Chunk a single content item
+   */
+  chunkContent(contentId, collectionId, title, data, metadata = {}) {
+    const text = this.extractText(data);
+    if (!text || text.trim().length === 0) {
+      console.warn(`[ChunkingService] No text found for content ${contentId}`);
+      return [];
+    }
+    const textChunks = this.splitIntoChunks(text);
+    return textChunks.map((chunkText, index) => ({
+      id: `${contentId}_chunk_${index}`,
+      content_id: contentId,
+      collection_id: collectionId,
+      title,
+      text: chunkText,
+      chunk_index: index,
+      metadata: {
+        ...metadata,
+        total_chunks: textChunks.length
+      }
+    }));
+  }
+  /**
+   * Chunk multiple content items
+   */
+  chunkContentBatch(items) {
+    const allChunks = [];
+    for (const item of items) {
+      const chunks = this.chunkContent(
+        item.id,
+        item.collection_id,
+        item.title,
+        item.data,
+        item.metadata
+      );
+      allChunks.push(...chunks);
+    }
+    return allChunks;
+  }
+  /**
+   * Extract all text from content data
+   */
+  extractText(data) {
+    const parts = [];
+    if (data.title) parts.push(String(data.title));
+    if (data.name) parts.push(String(data.name));
+    if (data.description) parts.push(String(data.description));
+    if (data.content) parts.push(String(data.content));
+    if (data.body) parts.push(String(data.body));
+    if (data.text) parts.push(String(data.text));
+    if (data.summary) parts.push(String(data.summary));
+    const extractRecursive = (obj) => {
+      if (typeof obj === "string") {
+        if (obj.length > 10 && !obj.startsWith("http")) {
+          parts.push(obj);
+        }
+      } else if (Array.isArray(obj)) {
+        obj.forEach(extractRecursive);
+      } else if (obj && typeof obj === "object") {
+        const skipKeys = ["id", "slug", "url", "image", "thumbnail", "metadata"];
+        Object.entries(obj).forEach(([key, value]) => {
+          if (!skipKeys.includes(key.toLowerCase())) {
+            extractRecursive(value);
+          }
+        });
+      }
+    };
+    extractRecursive(data);
+    return parts.join("\n\n").trim();
+  }
+  /**
+   * Split text into overlapping chunks
+   */
+  splitIntoChunks(text) {
+    const words = text.split(/\s+/);
+    if (words.length <= this.CHUNK_SIZE) {
+      return [text];
+    }
+    const chunks = [];
+    let startIndex = 0;
+    while (startIndex < words.length) {
+      const endIndex = Math.min(startIndex + this.CHUNK_SIZE, words.length);
+      const chunk = words.slice(startIndex, endIndex).join(" ");
+      chunks.push(chunk);
+      startIndex += this.CHUNK_SIZE - this.CHUNK_OVERLAP;
+      if (startIndex >= words.length - this.CHUNK_OVERLAP) {
+        break;
+      }
+    }
+    return chunks;
+  }
+  /**
+   * Get optimal chunk size based on content type
+   */
+  getOptimalChunkSize(contentType) {
+    switch (contentType) {
+      case "blog_posts":
+      case "articles":
+        return 600;
+      // Larger chunks for long-form content
+      case "products":
+      case "pages":
+        return 400;
+      // Medium chunks for structured content
+      case "messages":
+      case "comments":
+        return 200;
+      // Small chunks for short content
+      default:
+        return this.CHUNK_SIZE;
+    }
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/custom-rag.service.ts
+var CustomRAGService = class {
+  constructor(db, ai, vectorize) {
+    this.db = db;
+    this.ai = ai;
+    this.vectorize = vectorize;
+    this.embeddingService = new EmbeddingService(ai);
+    this.chunkingService = new ChunkingService();
+  }
+  embeddingService;
+  chunkingService;
+  /**
+   * Index all content from a collection
+   */
+  async indexCollection(collectionId) {
+    console.log(`[CustomRAG] Starting indexing for collection: ${collectionId}`);
+    try {
+      const { results: contentItems } = await this.db.prepare(`
+          SELECT c.id, c.title, c.data, c.collection_id, c.status,
+                 c.created_at, c.updated_at, c.author_id,
+                 col.name as collection_name, col.display_name as collection_display_name
+          FROM content c
+          JOIN collections col ON c.collection_id = col.id
+          WHERE c.collection_id = ? AND c.status = 'published'
+        `).bind(collectionId).all();
+      const totalItems = contentItems?.length || 0;
+      if (totalItems === 0) {
+        console.log(`[CustomRAG] No content found in collection ${collectionId}`);
+        return { total_items: 0, total_chunks: 0, indexed_chunks: 0, errors: 0 };
+      }
+      const items = (contentItems || []).map((item) => ({
+        id: item.id,
+        collection_id: item.collection_id,
+        title: item.title || "Untitled",
+        data: typeof item.data === "string" ? JSON.parse(item.data) : item.data,
+        metadata: {
+          status: item.status,
+          created_at: item.created_at,
+          updated_at: item.updated_at,
+          author_id: item.author_id,
+          collection_name: item.collection_name,
+          collection_display_name: item.collection_display_name
+        }
+      }));
+      const chunks = this.chunkingService.chunkContentBatch(items);
+      const totalChunks = chunks.length;
+      console.log(`[CustomRAG] Generated ${totalChunks} chunks from ${totalItems} items`);
+      const embeddings = await this.embeddingService.generateBatch(
+        chunks.map((c) => `${c.title}
+
+${c.text}`)
+      );
+      console.log(`[CustomRAG] Generated ${embeddings.length} embeddings`);
+      let indexedChunks = 0;
+      let errors = 0;
+      const batchSize = 100;
+      for (let i = 0; i < chunks.length; i += batchSize) {
+        const chunkBatch = chunks.slice(i, i + batchSize);
+        const embeddingBatch = embeddings.slice(i, i + batchSize);
+        try {
+          await this.vectorize.upsert(
+            chunkBatch.map((chunk, idx) => ({
+              id: chunk.id,
+              values: embeddingBatch[idx],
+              metadata: {
+                content_id: chunk.content_id,
+                collection_id: chunk.collection_id,
+                title: chunk.title,
+                text: chunk.text.substring(0, 500),
+                // Store snippet for display
+                chunk_index: chunk.chunk_index,
+                ...chunk.metadata
+              }
+            }))
+          );
+          indexedChunks += chunkBatch.length;
+          console.log(`[CustomRAG] Indexed batch ${i / batchSize + 1}: ${chunkBatch.length} chunks`);
+        } catch (error) {
+          console.error(`[CustomRAG] Error indexing batch ${i / batchSize + 1}:`, error);
+          errors += chunkBatch.length;
+        }
+      }
+      console.log(`[CustomRAG] Indexing complete: ${indexedChunks}/${totalChunks} chunks indexed`);
+      return {
+        total_items: totalItems,
+        total_chunks: totalChunks,
+        indexed_chunks: indexedChunks,
+        errors
+      };
+    } catch (error) {
+      console.error(`[CustomRAG] Error indexing collection ${collectionId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Search using RAG (semantic search with Vectorize)
+   */
+  async search(query, settings) {
+    const startTime = Date.now();
+    try {
+      console.log(`[CustomRAG] Searching for: "${query.query}"`);
+      const queryEmbedding = await this.embeddingService.generateEmbedding(query.query);
+      const filter = {};
+      if (query.filters?.collections && query.filters.collections.length > 0) {
+        filter.collection_id = { $in: query.filters.collections };
+      } else if (settings.selected_collections.length > 0) {
+        filter.collection_id = { $in: settings.selected_collections };
+      }
+      if (query.filters?.status && query.filters.status.length > 0) {
+        filter.status = { $in: query.filters.status };
+      }
+      const vectorResults = await this.vectorize.query(queryEmbedding, {
+        topK: 50,
+        // Max allowed with returnMetadata: true
+        returnMetadata: true
+      });
+      let filteredMatches = vectorResults.matches || [];
+      if (filter.collection_id?.$in && Array.isArray(filter.collection_id.$in)) {
+        const allowedCollections = filter.collection_id.$in;
+        filteredMatches = filteredMatches.filter(
+          (match) => allowedCollections.includes(match.metadata?.collection_id)
+        );
+      }
+      if (filter.status?.$in && Array.isArray(filter.status.$in)) {
+        const allowedStatuses = filter.status.$in;
+        filteredMatches = filteredMatches.filter(
+          (match) => allowedStatuses.includes(match.metadata?.status)
+        );
+      }
+      const topK = query.limit || settings.results_limit || 20;
+      filteredMatches = filteredMatches.slice(0, topK);
+      vectorResults.matches = filteredMatches;
+      if (!vectorResults.matches || vectorResults.matches.length === 0) {
+        return {
+          results: [],
+          total: 0,
+          query_time_ms: Date.now() - startTime,
+          mode: "ai"
+        };
+      }
+      const contentIds = [...new Set(
+        vectorResults.matches.map((m) => m.metadata.content_id)
+      )];
+      const placeholders = contentIds.map(() => "?").join(",");
+      const { results: contentItems } = await this.db.prepare(`
+          SELECT c.id, c.title, c.slug, c.collection_id, c.status,
+                 c.created_at, c.updated_at, c.author_id,
+                 col.display_name as collection_name
+          FROM content c
+          JOIN collections col ON c.collection_id = col.id
+          WHERE c.id IN (${placeholders})
+        `).bind(...contentIds).all();
+      const searchResults = (contentItems || []).map((item) => {
+        const matchingChunks = vectorResults.matches.filter(
+          (m) => m.metadata.content_id === item.id
+        );
+        const bestMatch = matchingChunks.reduce(
+          (best, current) => current.score > (best?.score || 0) ? current : best,
+          null
+        );
+        return {
+          id: item.id,
+          title: item.title || "Untitled",
+          slug: item.slug || "",
+          collection_id: item.collection_id,
+          collection_name: item.collection_name,
+          snippet: bestMatch?.metadata?.text || "",
+          relevance_score: bestMatch?.score || 0,
+          status: item.status,
+          created_at: item.created_at,
+          updated_at: item.updated_at
+        };
+      });
+      searchResults.sort((a, b) => (b.relevance_score || 0) - (a.relevance_score || 0));
+      const queryTime = Date.now() - startTime;
+      console.log(`[CustomRAG] Search completed in ${queryTime}ms, ${searchResults.length} results`);
+      return {
+        results: searchResults,
+        total: searchResults.length,
+        query_time_ms: queryTime,
+        mode: "ai"
+      };
+    } catch (error) {
+      console.error("[CustomRAG] Search error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Update index for a single content item
+   */
+  async updateContentIndex(contentId) {
+    try {
+      const content2 = await this.db.prepare(`
+          SELECT c.id, c.title, c.data, c.collection_id, c.status,
+                 c.created_at, c.updated_at, c.author_id,
+                 col.name as collection_name, col.display_name as collection_display_name
+          FROM content c
+          JOIN collections col ON c.collection_id = col.id
+          WHERE c.id = ?
+        `).bind(contentId).first();
+      if (!content2) {
+        console.warn(`[CustomRAG] Content ${contentId} not found`);
+        return;
+      }
+      if (content2.status !== "published") {
+        await this.removeContentFromIndex(contentId);
+        return;
+      }
+      const chunks = this.chunkingService.chunkContent(
+        content2.id,
+        content2.collection_id,
+        content2.title || "Untitled",
+        typeof content2.data === "string" ? JSON.parse(content2.data) : content2.data,
+        {
+          status: content2.status,
+          created_at: content2.created_at,
+          updated_at: content2.updated_at,
+          author_id: content2.author_id,
+          collection_name: content2.collection_name,
+          collection_display_name: content2.collection_display_name
+        }
+      );
+      const embeddings = await this.embeddingService.generateBatch(
+        chunks.map((c) => `${c.title}
+
+${c.text}`)
+      );
+      await this.vectorize.upsert(
+        chunks.map((chunk, idx) => ({
+          id: chunk.id,
+          values: embeddings[idx],
+          metadata: {
+            content_id: chunk.content_id,
+            collection_id: chunk.collection_id,
+            title: chunk.title,
+            text: chunk.text.substring(0, 500),
+            chunk_index: chunk.chunk_index,
+            ...chunk.metadata
+          }
+        }))
+      );
+      console.log(`[CustomRAG] Updated index for content ${contentId}: ${chunks.length} chunks`);
+    } catch (error) {
+      console.error(`[CustomRAG] Error updating index for ${contentId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Remove content from index
+   */
+  async removeContentFromIndex(contentId) {
+    try {
+      console.log(`[CustomRAG] Removing content ${contentId} from index`);
+    } catch (error) {
+      console.error(`[CustomRAG] Error removing content ${contentId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get search suggestions based on query
+   */
+  async getSuggestions(partialQuery, limit = 5) {
+    try {
+      const queryEmbedding = await this.embeddingService.generateEmbedding(partialQuery);
+      const results = await this.vectorize.query(queryEmbedding, {
+        topK: limit * 2,
+        // Get more to filter
+        returnMetadata: true
+      });
+      const suggestions = [...new Set(
+        results.matches?.map((m) => m.metadata.title).filter(Boolean) || []
+      )].slice(0, limit);
+      return suggestions;
+    } catch (error) {
+      console.error("[CustomRAG] Error getting suggestions:", error);
+      return [];
+    }
+  }
+  /**
+   * Check if Vectorize is available and configured
+   */
+  isAvailable() {
+    return !!this.vectorize && !!this.ai;
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/ai-search.ts
+var AISearchService = class {
+  constructor(db, ai, vectorize) {
+    this.db = db;
+    this.ai = ai;
+    this.vectorize = vectorize;
+    if (this.ai && this.vectorize) {
+      this.customRAG = new CustomRAGService(db, ai, vectorize);
+      console.log("[AISearchService] Custom RAG initialized");
+    } else {
+      console.log("[AISearchService] Custom RAG not available, using keyword search only");
+    }
+  }
+  customRAG;
+  /**
+   * Get plugin settings
+   */
+  async getSettings() {
+    try {
+      const plugin = await this.db.prepare(`SELECT settings FROM plugins WHERE id = ? LIMIT 1`).bind("ai-search").first();
+      if (!plugin || !plugin.settings) {
+        return this.getDefaultSettings();
+      }
+      return JSON.parse(plugin.settings);
+    } catch (error) {
+      console.error("Error fetching AI Search settings:", error);
+      return this.getDefaultSettings();
+    }
+  }
+  /**
+   * Get default settings
+   */
+  getDefaultSettings() {
+    return {
+      enabled: true,
+      ai_mode_enabled: true,
+      selected_collections: [],
+      dismissed_collections: [],
+      autocomplete_enabled: true,
+      cache_duration: 1,
+      results_limit: 20,
+      index_media: false
+    };
+  }
+  /**
+   * Update plugin settings
+   */
+  async updateSettings(settings) {
+    const existing = await this.getSettings();
+    const updated = {
+      ...existing,
+      ...settings
+    };
+    try {
+      await this.db.prepare(`
+          UPDATE plugins
+          SET settings = ?,
+              updated_at = unixepoch()
+          WHERE id = 'ai-search'
+        `).bind(JSON.stringify(updated)).run();
+      return updated;
+    } catch (error) {
+      console.error("Error updating AI Search settings:", error);
+      throw error;
+    }
+  }
+  /**
+   * Detect new collections that aren't indexed or dismissed
+   */
+  async detectNewCollections() {
+    try {
+      const collectionsStmt = this.db.prepare(
+        "SELECT id, name, display_name, description FROM collections WHERE is_active = 1"
+      );
+      const { results: allCollections } = await collectionsStmt.all();
+      const collections2 = (allCollections || []).filter(
+        (col) => {
+          if (!col.name) return false;
+          const name = col.name.toLowerCase();
+          return !name.startsWith("test_") && !name.endsWith("_test") && name !== "test_collection" && !name.includes("_test_") && name !== "large_payload_test" && name !== "concurrent_test";
+        }
+      );
+      const settings = await this.getSettings();
+      const selected = settings?.selected_collections || [];
+      const dismissed = settings?.dismissed_collections || [];
+      const notifications = [];
+      for (const collection of collections2 || []) {
+        const collectionId = String(collection.id);
+        if (selected.includes(collectionId) || dismissed.includes(collectionId)) {
+          continue;
+        }
+        const countStmt = this.db.prepare(
+          "SELECT COUNT(*) as count FROM content WHERE collection_id = ?"
+        );
+        const countResult = await countStmt.bind(collectionId).first();
+        const itemCount = countResult?.count || 0;
+        notifications.push({
+          collection: {
+            id: collectionId,
+            name: collection.name,
+            display_name: collection.display_name,
+            description: collection.description,
+            item_count: itemCount,
+            is_indexed: false,
+            is_dismissed: false,
+            is_new: true
+          },
+          message: `New collection "${collection.display_name}" with ${itemCount} items available for indexing`
+        });
+      }
+      return notifications;
+    } catch (error) {
+      console.error("Error detecting new collections:", error);
+      return [];
+    }
+  }
+  /**
+   * Get all collections with indexing status
+   */
+  async getAllCollections() {
+    try {
+      const collectionsStmt = this.db.prepare(
+        "SELECT id, name, display_name, description FROM collections WHERE is_active = 1 ORDER BY display_name"
+      );
+      const { results: allCollections } = await collectionsStmt.all();
+      console.log("[AISearchService.getAllCollections] Raw collections from DB:", allCollections?.length || 0);
+      const firstCollection = allCollections?.[0];
+      if (firstCollection) {
+        console.log("[AISearchService.getAllCollections] Sample collection:", {
+          id: firstCollection.id,
+          name: firstCollection.name,
+          display_name: firstCollection.display_name
+        });
+      }
+      const collections2 = (allCollections || []).filter(
+        (col) => col.id && col.name
+      );
+      console.log("[AISearchService.getAllCollections] After filtering test collections:", collections2.length);
+      console.log("[AISearchService.getAllCollections] Remaining collections:", collections2.map((c) => c.name).join(", "));
+      const settings = await this.getSettings();
+      const selected = settings?.selected_collections || [];
+      const dismissed = settings?.dismissed_collections || [];
+      console.log("[AISearchService.getAllCollections] Settings:", {
+        selected_count: selected.length,
+        dismissed_count: dismissed.length,
+        selected
+      });
+      const collectionInfos = [];
+      for (const collection of collections2) {
+        if (!collection.id || !collection.name) continue;
+        const collectionId = String(collection.id);
+        if (!collectionId) {
+          console.warn("[AISearchService] Skipping invalid collection:", collection);
+          continue;
+        }
+        const countStmt = this.db.prepare(
+          "SELECT COUNT(*) as count FROM content WHERE collection_id = ?"
+        );
+        const countResult = await countStmt.bind(collectionId).first();
+        const itemCount = countResult?.count || 0;
+        collectionInfos.push({
+          id: collectionId,
+          name: collection.name,
+          display_name: collection.display_name || collection.name,
+          description: collection.description,
+          item_count: itemCount,
+          is_indexed: selected.includes(collectionId),
+          is_dismissed: dismissed.includes(collectionId),
+          is_new: !selected.includes(collectionId) && !dismissed.includes(collectionId)
+        });
+      }
+      console.log("[AISearchService.getAllCollections] Returning collectionInfos:", collectionInfos.length);
+      const firstInfo = collectionInfos[0];
+      if (collectionInfos.length > 0 && firstInfo) {
+        console.log("[AISearchService.getAllCollections] First collectionInfo:", {
+          id: firstInfo.id,
+          name: firstInfo.name,
+          display_name: firstInfo.display_name,
+          item_count: firstInfo.item_count
+        });
+      }
+      return collectionInfos;
+    } catch (error) {
+      console.error("[AISearchService] Error fetching collections:", error);
+      return [];
+    }
+  }
+  /**
+   * Execute search query
+   */
+  async search(query) {
+    const settings = await this.getSettings();
+    if (!settings?.enabled) {
+      return {
+        results: [],
+        total: 0,
+        query_time_ms: 0,
+        mode: query.mode
+      };
+    }
+    if (query.mode === "ai" && settings.ai_mode_enabled && this.customRAG?.isAvailable()) {
+      return this.searchAI(query, settings);
+    }
+    return this.searchKeyword(query, settings);
+  }
+  /**
+   * AI-powered semantic search using Custom RAG
+   */
+  async searchAI(query, settings) {
+    try {
+      if (!this.customRAG) {
+        console.warn("[AISearchService] CustomRAG not available, falling back to keyword search");
+        return this.searchKeyword(query, settings);
+      }
+      const result = await this.customRAG.search(query, settings);
+      return result;
+    } catch (error) {
+      console.error("[AISearchService] AI search error, falling back to keyword:", error);
+      return this.searchKeyword(query, settings);
+    }
+  }
+  /**
+   * Traditional keyword search
+   */
+  async searchKeyword(query, settings) {
+    const startTime = Date.now();
+    try {
+      const conditions = [];
+      const params = [];
+      if (query.query) {
+        conditions.push("(c.title LIKE ? OR c.slug LIKE ? OR c.data LIKE ?)");
+        const searchTerm = `%${query.query}%`;
+        params.push(searchTerm, searchTerm, searchTerm);
+      }
+      if (query.filters?.collections && query.filters.collections.length > 0) {
+        const placeholders = query.filters.collections.map(() => "?").join(",");
+        conditions.push(`c.collection_id IN (${placeholders})`);
+        params.push(...query.filters.collections);
+      } else if (settings.selected_collections.length > 0) {
+        const placeholders = settings.selected_collections.map(() => "?").join(",");
+        conditions.push(`c.collection_id IN (${placeholders})`);
+        params.push(...settings.selected_collections);
+      }
+      if (query.filters?.status && query.filters.status.length > 0) {
+        const placeholders = query.filters.status.map(() => "?").join(",");
+        conditions.push(`c.status IN (${placeholders})`);
+        params.push(...query.filters.status);
+      } else {
+        conditions.push("c.status != 'deleted'");
+      }
+      if (query.filters?.dateRange) {
+        const field = query.filters.dateRange.field || "created_at";
+        if (query.filters.dateRange.start) {
+          conditions.push(`c.${field} >= ?`);
+          params.push(query.filters.dateRange.start.getTime());
+        }
+        if (query.filters.dateRange.end) {
+          conditions.push(`c.${field} <= ?`);
+          params.push(query.filters.dateRange.end.getTime());
+        }
+      }
+      if (query.filters?.author) {
+        conditions.push("c.author_id = ?");
+        params.push(query.filters.author);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countStmt = this.db.prepare(`
+        SELECT COUNT(*) as count 
+        FROM content c
+        ${whereClause}
+      `);
+      const countResult = await countStmt.bind(...params).first();
+      const total = countResult?.count || 0;
+      const limit = query.limit || settings.results_limit;
+      const offset = query.offset || 0;
+      const resultsStmt = this.db.prepare(`
+        SELECT 
+          c.id, c.title, c.slug, c.collection_id, c.status,
+          c.created_at, c.updated_at, c.author_id, c.data,
+          col.name as collection_name, col.display_name as collection_display_name,
+          u.email as author_email
+        FROM content c
+        JOIN collections col ON c.collection_id = col.id
+        LEFT JOIN users u ON c.author_id = u.id
+        ${whereClause}
+        ORDER BY c.updated_at DESC
+        LIMIT ? OFFSET ?
+      `);
+      const { results } = await resultsStmt.bind(...params, limit, offset).all();
+      const searchResults = (results || []).map((row) => ({
+        id: String(row.id),
+        title: row.title || "Untitled",
+        slug: row.slug || "",
+        collection_id: String(row.collection_id),
+        collection_name: row.collection_display_name || row.collection_name,
+        snippet: this.extractSnippet(row.data, query.query),
+        status: row.status,
+        created_at: Number(row.created_at),
+        updated_at: Number(row.updated_at),
+        author_name: row.author_email
+      }));
+      const queryTime = Date.now() - startTime;
+      await this.logSearch(query.query, query.mode, searchResults.length);
+      return {
+        results: searchResults,
+        total,
+        query_time_ms: queryTime,
+        mode: query.mode
+      };
+    } catch (error) {
+      console.error("Keyword search error:", error);
+      return {
+        results: [],
+        total: 0,
+        query_time_ms: Date.now() - startTime,
+        mode: query.mode
+      };
+    }
+  }
+  /**
+   * Extract snippet from content data
+   */
+  extractSnippet(data, query) {
+    try {
+      const parsed = typeof data === "string" ? JSON.parse(data) : data;
+      const text = JSON.stringify(parsed).toLowerCase();
+      const queryLower = query.toLowerCase();
+      const index = text.indexOf(queryLower);
+      if (index === -1) {
+        return JSON.stringify(parsed).substring(0, 200) + "...";
+      }
+      const start = Math.max(0, index - 50);
+      const end = Math.min(text.length, index + query.length + 50);
+      return text.substring(start, end) + "...";
+    } catch {
+      return data.substring(0, 200) + "...";
+    }
+  }
+  /**
+   * Get search suggestions (autocomplete)
+   */
+  async getSearchSuggestions(partial) {
+    try {
+      const settings = await this.getSettings();
+      if (!settings?.autocomplete_enabled) {
+        return [];
+      }
+      if (this.customRAG?.isAvailable()) {
+        try {
+          const aiSuggestions = await this.customRAG.getSuggestions(partial, 5);
+          if (aiSuggestions.length > 0) {
+            return aiSuggestions;
+          }
+        } catch (error) {
+          console.error("[AISearchService] Error getting AI suggestions:", error);
+        }
+      }
+      const stmt = this.db.prepare(`
+        SELECT DISTINCT query 
+        FROM ai_search_history 
+        WHERE query LIKE ? 
+        ORDER BY created_at DESC 
+        LIMIT 10
+      `);
+      const { results } = await stmt.bind(`%${partial}%`).all();
+      return (results || []).map((r) => r.query);
+    } catch (error) {
+      console.error("Error getting suggestions:", error);
+      return [];
+    }
+  }
+  /**
+   * Log search query to history
+   */
+  async logSearch(query, mode, resultsCount) {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO ai_search_history (query, mode, results_count, created_at)
+        VALUES (?, ?, ?, ?)
+      `);
+      await stmt.bind(query, mode, resultsCount, Date.now()).run();
+    } catch (error) {
+      console.error("Error logging search:", error);
+    }
+  }
+  /**
+   * Get search analytics
+   */
+  async getSearchAnalytics() {
+    try {
+      const totalStmt = this.db.prepare(`
+        SELECT COUNT(*) as count 
+        FROM ai_search_history 
+        WHERE created_at >= ?
+      `);
+      const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1e3;
+      const totalResult = await totalStmt.bind(thirtyDaysAgo).first();
+      const modeStmt = this.db.prepare(`
+        SELECT mode, COUNT(*) as count 
+        FROM ai_search_history 
+        WHERE created_at >= ?
+        GROUP BY mode
+      `);
+      const { results: modeResults } = await modeStmt.bind(thirtyDaysAgo).all();
+      const aiCount = modeResults?.find((r) => r.mode === "ai")?.count || 0;
+      const keywordCount = modeResults?.find((r) => r.mode === "keyword")?.count || 0;
+      const popularStmt = this.db.prepare(`
+        SELECT query, COUNT(*) as count 
+        FROM ai_search_history 
+        WHERE created_at >= ?
+        GROUP BY query 
+        ORDER BY count DESC 
+        LIMIT 10
+      `);
+      const { results: popularResults } = await popularStmt.bind(thirtyDaysAgo).all();
+      return {
+        total_queries: totalResult?.count || 0,
+        ai_queries: aiCount,
+        keyword_queries: keywordCount,
+        popular_queries: (popularResults || []).map((r) => ({
+          query: r.query,
+          count: r.count
+        })),
+        average_query_time: 0
+        // TODO: Track query times
+      };
+    } catch (error) {
+      console.error("Error getting analytics:", error);
+      return {
+        total_queries: 0,
+        ai_queries: 0,
+        keyword_queries: 0,
+        popular_queries: [],
+        average_query_time: 0
+      };
+    }
+  }
+  /**
+   * Verify Custom RAG is available
+   */
+  verifyBinding() {
+    return this.customRAG?.isAvailable() ?? false;
+  }
+  /**
+   * Get Custom RAG service instance (for indexer)
+   */
+  getCustomRAG() {
+    return this.customRAG;
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/services/indexer.ts
+var IndexManager = class {
+  constructor(db, ai, vectorize) {
+    this.db = db;
+    this.ai = ai;
+    this.vectorize = vectorize;
+    if (this.ai && this.vectorize) {
+      this.customRAG = new CustomRAGService(db, ai, vectorize);
+      console.log("[IndexManager] Custom RAG initialized");
+    }
+  }
+  customRAG;
+  /**
+   * Index all content items within a collection using Custom RAG
+   */
+  async indexCollection(collectionId) {
+    try {
+      const collectionStmt = this.db.prepare(
+        "SELECT id, name, display_name FROM collections WHERE id = ?"
+      );
+      const collection = await collectionStmt.bind(collectionId).first();
+      if (!collection) {
+        throw new Error(`Collection ${collectionId} not found`);
+      }
+      await this.updateIndexStatus(collectionId, {
+        collection_id: collectionId,
+        collection_name: collection.display_name,
+        total_items: 0,
+        indexed_items: 0,
+        status: "indexing"
+      });
+      if (this.customRAG?.isAvailable()) {
+        console.log(`[IndexManager] Using Custom RAG to index collection ${collectionId}`);
+        const result = await this.customRAG.indexCollection(collectionId);
+        const finalStatus = {
+          collection_id: collectionId,
+          collection_name: collection.display_name,
+          total_items: result.total_items,
+          indexed_items: result.indexed_chunks,
+          last_sync_at: Date.now(),
+          status: result.errors > 0 ? "error" : "completed",
+          error_message: result.errors > 0 ? `${result.errors} errors during indexing` : void 0
+        };
+        await this.updateIndexStatus(collectionId, finalStatus);
+        return finalStatus;
+      }
+      console.warn(`[IndexManager] Custom RAG not available, skipping indexing for ${collectionId}`);
+      const fallbackStatus = {
+        collection_id: collectionId,
+        collection_name: collection.display_name,
+        total_items: 0,
+        indexed_items: 0,
+        last_sync_at: Date.now(),
+        status: "completed",
+        error_message: "Custom RAG not available - using keyword search only"
+      };
+      await this.updateIndexStatus(collectionId, fallbackStatus);
+      return fallbackStatus;
+    } catch (error) {
+      console.error(`[IndexManager] Error indexing collection ${collectionId}:`, error);
+      const errorStatus = {
+        collection_id: collectionId,
+        collection_name: "Unknown",
+        total_items: 0,
+        indexed_items: 0,
+        status: "error",
+        error_message: error instanceof Error ? error.message : String(error)
+      };
+      await this.updateIndexStatus(collectionId, errorStatus);
+      return errorStatus;
+    }
+  }
+  /**
+   * Index a single content item
+   */
+  async indexContentItem(item, collectionId) {
+    try {
+      let parsedData = {};
+      try {
+        parsedData = typeof item.data === "string" ? JSON.parse(item.data) : item.data;
+      } catch {
+        parsedData = {};
+      }
+      const document = {
+        id: `content_${item.id}`,
+        title: item.title || "Untitled",
+        slug: item.slug || "",
+        content: this.extractSearchableText(parsedData),
+        metadata: {
+          collection_id: collectionId,
+          collection_name: item.collection_name,
+          collection_display_name: item.collection_display_name,
+          status: item.status,
+          created_at: item.created_at,
+          updated_at: item.updated_at,
+          author_id: item.author_id
+        }
+      };
+      console.log(`Indexed content item: ${item.id}`);
+    } catch (error) {
+      console.error(`Error indexing content item ${item.id}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Extract searchable text from content data
+   */
+  extractSearchableText(data) {
+    const parts = [];
+    if (data.title) parts.push(String(data.title));
+    if (data.name) parts.push(String(data.name));
+    if (data.description) parts.push(String(data.description));
+    if (data.content) parts.push(String(data.content));
+    if (data.body) parts.push(String(data.body));
+    if (data.text) parts.push(String(data.text));
+    const extractStrings = (obj) => {
+      if (typeof obj === "string") {
+        parts.push(obj);
+      } else if (Array.isArray(obj)) {
+        obj.forEach(extractStrings);
+      } else if (obj && typeof obj === "object") {
+        Object.values(obj).forEach(extractStrings);
+      }
+    };
+    extractStrings(data);
+    return parts.join(" ");
+  }
+  /**
+   * Update a single content item in the index
+   */
+  async updateIndex(collectionId, contentId) {
+    try {
+      const stmt = this.db.prepare(`
+            SELECT 
+              c.id, c.title, c.slug, c.data, c.status,
+              c.created_at, c.updated_at, c.author_id,
+              col.name as collection_name, col.display_name as collection_display_name
+            FROM content c
+            JOIN collections col ON c.collection_id = col.id
+            WHERE c.id = ? AND c.collection_id = ?
+          `);
+      const item = await stmt.bind(contentId, collectionId).first();
+      if (!item) {
+        throw new Error(`Content item ${contentId} not found`);
+      }
+      await this.indexContentItem(item, String(collectionId));
+      const status = await this.getIndexStatus(String(collectionId));
+      if (status) {
+        await this.updateIndexStatus(String(collectionId), {
+          ...status,
+          last_sync_at: Date.now()
+        });
+      }
+    } catch (error) {
+      console.error(`Error updating index for content ${contentId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Remove a content item from the index using Custom RAG
+   */
+  async removeFromIndex(collectionId, contentId) {
+    try {
+      if (this.customRAG?.isAvailable()) {
+        console.log(`[IndexManager] Removing content ${contentId} from index`);
+        await this.customRAG.removeContentFromIndex(contentId);
+      } else {
+        console.warn(`[IndexManager] Custom RAG not available, skipping removal for ${contentId}`);
+      }
+    } catch (error) {
+      console.error(`[IndexManager] Error removing content ${contentId} from index:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get indexing status for a collection
+   */
+  async getIndexStatus(collectionId) {
+    try {
+      const stmt = this.db.prepare(
+        "SELECT * FROM ai_search_index_meta WHERE collection_id = ?"
+      );
+      const result = await stmt.bind(collectionId).first();
+      if (!result) {
+        return null;
+      }
+      return {
+        collection_id: String(result.collection_id),
+        collection_name: result.collection_name,
+        total_items: result.total_items,
+        indexed_items: result.indexed_items,
+        last_sync_at: result.last_sync_at,
+        status: result.status,
+        error_message: result.error_message
+      };
+    } catch (error) {
+      console.error(`Error getting index status for collection ${collectionId}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Get indexing status for all collections
+   */
+  async getAllIndexStatus() {
+    try {
+      const stmt = this.db.prepare("SELECT * FROM ai_search_index_meta");
+      const { results } = await stmt.all();
+      const statusMap = {};
+      for (const row of results || []) {
+        const collectionId = String(row.collection_id);
+        statusMap[collectionId] = {
+          collection_id: collectionId,
+          collection_name: row.collection_name,
+          total_items: row.total_items,
+          indexed_items: row.indexed_items,
+          last_sync_at: row.last_sync_at,
+          status: row.status,
+          error_message: row.error_message
+        };
+      }
+      return statusMap;
+    } catch (error) {
+      console.error("Error getting all index status:", error);
+      return {};
+    }
+  }
+  /**
+   * Update index status in database
+   */
+  async updateIndexStatus(collectionId, status) {
+    try {
+      const checkStmt = this.db.prepare(
+        "SELECT id FROM ai_search_index_meta WHERE collection_id = ?"
+      );
+      const existing = await checkStmt.bind(collectionId).first();
+      if (existing) {
+        const stmt = this.db.prepare(`
+              UPDATE ai_search_index_meta 
+              SET collection_name = ?,
+                  total_items = ?,
+                  indexed_items = ?,
+                  last_sync_at = ?,
+                  status = ?,
+                  error_message = ?
+              WHERE collection_id = ?
+            `);
+        await stmt.bind(
+          status.collection_name,
+          status.total_items,
+          status.indexed_items,
+          status.last_sync_at || null,
+          status.status,
+          status.error_message || null,
+          String(collectionId)
+        ).run();
+      } else {
+        const stmt = this.db.prepare(`
+              INSERT INTO ai_search_index_meta (
+                collection_id, collection_name, total_items, indexed_items,
+                last_sync_at, status, error_message
+              ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            `);
+        await stmt.bind(
+          String(status.collection_id),
+          status.collection_name,
+          status.total_items,
+          status.indexed_items,
+          status.last_sync_at || null,
+          status.status,
+          status.error_message || null
+        ).run();
+      }
+    } catch (error) {
+      console.error(`Error updating index status for collection ${collectionId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Sync all selected collections
+   */
+  async syncAll(selectedCollections) {
+    for (const collectionId of selectedCollections) {
+      try {
+        await this.indexCollection(collectionId);
+      } catch (error) {
+        console.error(`Error syncing collection ${collectionId}:`, error);
+      }
+    }
+  }
+};
+
+// src/plugins/core-plugins/ai-search-plugin/components/settings-page.ts
+function renderSettingsPage(data) {
+  const settings = data.settings || {
+    enabled: false,
+    ai_mode_enabled: true,
+    selected_collections: [],
+    dismissed_collections: [],
+    autocomplete_enabled: true,
+    cache_duration: 1,
+    results_limit: 20,
+    index_media: false
+  };
+  const selectedCollections = Array.isArray(settings.selected_collections) ? settings.selected_collections : [];
+  const dismissedCollections = Array.isArray(settings.dismissed_collections) ? settings.dismissed_collections : [];
+  const enabled = settings.enabled === true;
+  const aiModeEnabled = settings.ai_mode_enabled !== false;
+  const autocompleteEnabled = settings.autocomplete_enabled !== false;
+  const indexMedia = settings.index_media === true;
+  const selectedCollectionIds = new Set(selectedCollections.map((id) => String(id)));
+  const dismissedCollectionIds = new Set(dismissedCollections.map((id) => String(id)));
+  const collections2 = Array.isArray(data.collections) ? data.collections : [];
+  console.log("[SettingsPage Template] Collections received:", collections2.length);
+  if (collections2.length > 0) {
+    console.log("[SettingsPage Template] First collection:", collections2[0]);
+  }
+  const content2 = `
+    <div class="w-full px-4 sm:px-6 lg:px-8 py-6">
+      <!-- Header with Back Button -->
+      <div class="flex flex-col sm:flex-row sm:items-center sm:justify-between mb-6">
+        <div>
+          <h1 class="text-2xl/8 font-semibold text-zinc-950 dark:text-white sm:text-xl/8">\u{1F50D} AI Search Settings</h1>
+          <p class="mt-2 text-sm/6 text-zinc-500 dark:text-zinc-400">
+            Configure advanced search with Cloudflare AI Search. Select collections to index and manage search preferences.
+          </p>
+        </div>
+        <div class="mt-4 sm:mt-0 sm:ml-16 sm:flex-none">
+          <a href="/admin/plugins" class="inline-flex items-center justify-center rounded-lg bg-white dark:bg-zinc-800 px-3.5 py-2.5 text-sm font-semibold text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 hover:bg-zinc-50 dark:hover:bg-zinc-700 transition-colors shadow-sm">
+            <svg class="-ml-0.5 mr-1.5 h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 19l-7-7m0 0l7-7m-7 7h18"/>
+            </svg>
+            Back to Plugins
+          </a>
+        </div>
+      </div>
+
+
+          <!-- Main Settings Card -->
+          <div class="rounded-xl bg-white dark:bg-zinc-900 shadow-sm ring-1 ring-zinc-950/5 dark:ring-white/10 p-6 mb-6">
+            <form id="settingsForm" class="space-y-6">
+              <!-- Enable Search Section -->
+              <div>
+                <h2 class="text-xl font-semibold text-zinc-950 dark:text-white mb-4">\u{1F50D} Search Settings</h2>
+                <div class="space-y-3">
+                  <div class="flex items-center gap-3 p-4 border border-indigo-200 bg-indigo-50 dark:bg-indigo-900/20 rounded-lg">
+                    <input type="checkbox" id="enabled" name="enabled" ${enabled ? "checked" : ""} class="w-5 h-5 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500 cursor-pointer">
+                    <div class="flex-1">
+                      <label for="enabled" class="text-base font-semibold text-zinc-900 dark:text-white select-none cursor-pointer block">Enable AI Search</label>
+                      <p class="text-xs text-zinc-600 dark:text-zinc-400 mt-0.5">Turn on advanced search capabilities across your content</p>
+                    </div>
+                  </div>
+
+                  <div class="flex items-center gap-3 p-4 border border-blue-200 bg-blue-50 dark:bg-blue-900/20 rounded-lg">
+                    <input type="checkbox" id="ai_mode_enabled" name="ai_mode_enabled" ${aiModeEnabled ? "checked" : ""} class="w-5 h-5 rounded border-gray-300 text-blue-600 focus:ring-blue-500 cursor-pointer">
+                    <div class="flex-1">
+                      <label for="ai_mode_enabled" class="text-base font-semibold text-zinc-900 dark:text-white select-none cursor-pointer block">\u{1F916} AI/Semantic Search</label>
+                      <p class="text-xs text-zinc-600 dark:text-zinc-400 mt-0.5">
+                        Enable natural language queries (requires Cloudflare Workers AI binding)
+                        <a href="https://developers.cloudflare.com/workers-ai/" target="_blank" class="text-blue-600 dark:text-blue-400 hover:underline ml-1">\u2192 Setup Guide</a>
+                      </p>
+                      <p class="text-xs text-amber-600 dark:text-amber-400 mt-1">
+                        \u26A0\uFE0F If AI binding unavailable, will fallback to keyword search
+                      </p>
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              <hr class="border-zinc-200 dark:border-zinc-800">
+
+              <!-- Collections Section -->
+              <div>
+                <div class="flex items-start justify-between mb-4">
+                  <div>
+                    <h2 class="text-xl font-semibold text-zinc-950 dark:text-white">\u{1F4DA} Collections to Index</h2>
+                    <p class="text-sm text-zinc-600 dark:text-zinc-400 mt-1">
+                      Select which content collections should be indexed and searchable. Only checked collections will be included in search results.
+                    </p>
+                  </div>
+                </div>
+            <div class="space-y-3 max-h-96 overflow-y-auto border-2 border-zinc-300 dark:border-zinc-700 rounded-lg p-4 bg-white dark:bg-zinc-800" id="collections-list">
+              ${collections2.length === 0 ? '<p class="text-sm text-zinc-500 dark:text-zinc-400 p-4">No collections available. Create collections first.</p>' : collections2.map((collection) => {
+    const collectionId = String(collection.id);
+    const isChecked = selectedCollectionIds.has(collectionId);
+    const isDismissed = dismissedCollectionIds.has(collectionId);
+    const indexStatusMap = data.indexStatus || {};
+    const status = indexStatusMap[collectionId];
+    const isNew = collection.is_new === true && !isDismissed && !status;
+    const statusBadge = status && isChecked ? `<span class="ml-2 px-2 py-1 text-xs rounded-full ${status.status === "completed" ? "bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-300" : status.status === "indexing" ? "bg-blue-100 text-blue-800 dark:bg-blue-900/30 dark:text-blue-300" : status.status === "error" ? "bg-red-100 text-red-800 dark:bg-red-900/30 dark:text-red-300" : "bg-gray-100 text-gray-800 dark:bg-gray-800 dark:text-gray-300"}">${status.status}</span>` : "";
+    return `<div class="flex items-start gap-3 p-3 rounded-lg border border-zinc-200 dark:border-zinc-700 ${isNew ? "bg-blue-50 dark:bg-blue-900/10 border-blue-200 dark:border-blue-800" : "hover:bg-zinc-50 dark:hover:bg-zinc-800"}">
+                      <input
+                        type="checkbox"
+                        id="collection_${collectionId}"
+                        name="selected_collections"
+                        value="${collectionId}"
+                        ${isChecked ? "checked" : ""}
+                        class="mt-1 w-5 h-5 text-indigo-600 bg-white border-gray-300 rounded focus:ring-indigo-500 focus:ring-2 cursor-pointer"
+                        style="cursor: pointer; flex-shrink: 0;"
+                      />
+                      <div class="flex-1 min-w-0">
+                        <label for="collection_${collectionId}" class="text-sm font-medium text-zinc-950 dark:text-white select-none cursor-pointer flex items-center">
+                          ${collection.display_name || collection.name || "Unnamed Collection"}
+                          ${isNew ? '<span class="ml-2 px-2 py-0.5 text-xs rounded-full bg-blue-100 text-blue-800 dark:bg-blue-900/30 dark:text-blue-300">NEW</span>' : ""}
+                          ${statusBadge}
+                        </label>
+                        <p class="text-xs text-zinc-500 dark:text-zinc-400 mt-1">
+                          ${collection.description || collection.name || "No description"} \u2022 ${collection.item_count || 0} items
+                          ${status ? ` \u2022 ${status.indexed_items}/${status.total_items} indexed` : ""}
+                        </p>
+                        ${status && status.status === "indexing" ? `<div class="mt-2 w-full bg-gray-200 rounded-full h-2 dark:bg-gray-700">
+                              <div class="bg-blue-600 h-2 rounded-full" style="width: ${status.indexed_items / status.total_items * 100}%"></div>
+                            </div>` : ""}
+                      </div>
+                      ${isChecked ? `
+                        <button
+                          type="button"
+                          onclick="reindexCollection('${collectionId}')"
+                          class="px-3 py-1.5 text-xs font-medium text-white bg-indigo-600 hover:bg-indigo-700 rounded-md transition-colors flex items-center gap-1.5 whitespace-nowrap"
+                          ${status && status.status === "indexing" ? "disabled" : ""}
+                        >
+                          <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                          </svg>
+                          Re-index
+                        </button>
+                      ` : ""}
+                    </div>`;
+  }).join("")}
+            </div>
+          </div>
+
+              <hr class="border-zinc-200 dark:border-zinc-800">
+
+              <!-- Advanced Options -->
+              <div>
+                <h2 class="text-xl font-semibold text-zinc-950 dark:text-white mb-4">\u2699\uFE0F Advanced Options</h2>
+                <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+                  <div class="flex items-start gap-3 p-3 border border-zinc-200 dark:border-zinc-700 rounded-lg">
+                    <input type="checkbox" id="autocomplete_enabled" name="autocomplete_enabled" ${autocompleteEnabled ? "checked" : ""} class="mt-0.5 w-5 h-5 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500 cursor-pointer">
+                    <div>
+                      <label for="autocomplete_enabled" class="text-sm font-medium text-zinc-950 dark:text-white select-none cursor-pointer block">Autocomplete Suggestions</label>
+                      <p class="text-xs text-zinc-500 dark:text-zinc-400 mt-0.5">Show search suggestions as users type</p>
+                    </div>
+                  </div>
+
+                  <div class="flex items-start gap-3 p-3 border border-zinc-200 dark:border-zinc-700 rounded-lg">
+                    <input type="checkbox" id="index_media" name="index_media" ${indexMedia ? "checked" : ""} class="mt-0.5 w-5 h-5 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500 cursor-pointer">
+                    <div>
+                      <label for="index_media" class="text-sm font-medium text-zinc-950 dark:text-white select-none cursor-pointer block">Index Media Metadata</label>
+                      <p class="text-xs text-zinc-500 dark:text-zinc-400 mt-0.5">Include media files in search results</p>
+                    </div>
+                  </div>
+
+                  <div>
+                    <label class="block text-sm font-medium text-zinc-950 dark:text-white mb-2">Cache Duration (hours)</label>
+                    <input type="number" id="cache_duration" name="cache_duration" value="${settings.cache_duration || 1}" min="0" max="24" class="w-full rounded-lg bg-white dark:bg-white/5 px-3 py-2 text-sm text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 focus:ring-2 focus:ring-indigo-500">
+                  </div>
+                  <div>
+                    <label class="block text-sm font-medium text-zinc-950 dark:text-white mb-2">Results Per Page</label>
+                    <input type="number" id="results_limit" name="results_limit" value="${settings.results_limit || 20}" min="10" max="100" class="w-full rounded-lg bg-white dark:bg-white/5 px-3 py-2 text-sm text-zinc-950 dark:text-white ring-1 ring-inset ring-zinc-950/10 dark:ring-white/10 focus:ring-2 focus:ring-indigo-500">
+                  </div>
+                </div>
+          </div>
+
+              <!-- Save Button -->
+              <div class="flex items-center justify-between pt-4 border-t border-zinc-200 dark:border-zinc-800">
+                <p class="text-xs text-zinc-500 dark:text-zinc-400">
+                  \u{1F4A1} Collections marked as <span class="px-1.5 py-0.5 text-xs font-medium rounded-full bg-blue-500 text-white">NEW</span> haven't been indexed yet
+                </p>
+                <button type="submit" class="inline-flex items-center justify-center rounded-lg bg-indigo-600 text-white px-6 py-2.5 text-sm font-semibold hover:bg-indigo-500 shadow-sm transition-colors">
+                  \u{1F4BE} Save Settings
+                </button>
+              </div>
+        </form>
+      </div>
+
+
+          <!-- Search Analytics -->
+          <div class="rounded-xl bg-white dark:bg-zinc-900 shadow-sm ring-1 ring-zinc-950/5 dark:ring-white/10 p-6">
+            <h2 class="text-xl font-semibold text-zinc-950 dark:text-white mb-4">\u{1F4CA} Search Analytics</h2>
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+          <div class="p-4 rounded-lg bg-zinc-50 dark:bg-zinc-800">
+            <div class="text-sm text-zinc-500 dark:text-zinc-400">Total Queries</div>
+            <div class="text-2xl font-bold text-zinc-950 dark:text-white mt-1">${data.analytics.total_queries}</div>
+          </div>
+          <div class="p-4 rounded-lg bg-zinc-50 dark:bg-zinc-800">
+            <div class="text-sm text-zinc-500 dark:text-zinc-400">AI Queries</div>
+            <div class="text-2xl font-bold text-blue-600 dark:text-blue-400 mt-1">${data.analytics.ai_queries}</div>
+          </div>
+          <div class="p-4 rounded-lg bg-zinc-50 dark:bg-zinc-800">
+            <div class="text-sm text-zinc-500 dark:text-zinc-400">Keyword Queries</div>
+            <div class="text-2xl font-bold text-indigo-600 dark:text-indigo-400 mt-1">${data.analytics.keyword_queries}</div>
+          </div>
+        </div>
+        ${data.analytics.popular_queries.length > 0 ? `
+              <div>
+                <h3 class="text-sm font-semibold text-zinc-950 dark:text-white mb-2">Popular Searches</h3>
+                <div class="space-y-1">
+                  ${data.analytics.popular_queries.map(
+    (item) => `
+                      <div class="flex items-center justify-between text-sm">
+                        <span class="text-zinc-700 dark:text-zinc-300">"${item.query}"</span>
+                        <span class="text-zinc-500 dark:text-zinc-400">${item.count} times</span>
+                      </div>
+                    `
+  ).join("")}
+                </div>
+              </div>
+            ` : '<p class="text-sm text-zinc-500 dark:text-zinc-400">No search history yet.</p>'}
+      </div>
+
+          <!-- Success Message -->
+          <div id="msg" class="hidden fixed bottom-4 right-4 p-4 rounded-lg bg-green-50 text-green-900 border border-green-200 dark:bg-green-900/20 dark:text-green-100 dark:border-green-800 shadow-lg z-50">
+            <div class="flex items-center gap-2">
+              <span class="text-xl">\u2705</span>
+              <span class="font-semibold">Settings Saved Successfully!</span>
+            </div>
+          </div>
+    </div>
+    <script>
+      // Form submission with error handling
+      document.getElementById('settingsForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        console.log('[AI Search Client] Form submitted');
+        
+        try {
+          const btn = e.submitter;
+          btn.innerText = 'Saving...'; 
+          btn.disabled = true;
+          
+          const formData = new FormData(e.target);
+          const selectedCollections = Array.from(formData.getAll('selected_collections')).map(String);
+          
+          const data = {
+            enabled: document.getElementById('enabled').checked,
+            ai_mode_enabled: document.getElementById('ai_mode_enabled').checked,
+            selected_collections: selectedCollections,
+            autocomplete_enabled: document.getElementById('autocomplete_enabled').checked,
+            cache_duration: Number(formData.get('cache_duration')),
+            results_limit: Number(formData.get('results_limit')),
+            index_media: document.getElementById('index_media').checked,
+          };
+          
+          console.log('[AI Search Client] Sending data:', data);
+          console.log('[AI Search Client] Selected collections:', selectedCollections);
+          
+          const res = await fetch('/admin/plugins/ai-search', { 
+            method: 'POST', 
+            headers: {'Content-Type': 'application/json'}, 
+            body: JSON.stringify(data) 
+          });
+          
+          console.log('[AI Search Client] Response status:', res.status);
+          
+          if (res.ok) {
+            const result = await res.json();
+            console.log('[AI Search Client] Save successful:', result);
+            document.getElementById('msg').classList.remove('hidden'); 
+            setTimeout(() => {
+              document.getElementById('msg').classList.add('hidden');
+              location.reload();
+            }, 2000); 
+          } else {
+            const error = await res.text();
+            console.error('[AI Search Client] Save failed:', error);
+            alert('Failed to save settings: ' + error);
+          }
+          
+          btn.innerText = 'Save Settings'; 
+          btn.disabled = false;
+        } catch (error) {
+          console.error('[AI Search Client] Error:', error);
+          alert('Error saving settings: ' + error.message);
+        }
+      });
+
+      // Add collection to index
+      async function addCollectionToIndex(collectionId) {
+        const form = document.getElementById('settingsForm');
+        const checkbox = document.getElementById('collection_' + collectionId);
+        if (checkbox) {
+          checkbox.checked = true;
+          form.dispatchEvent(new Event('submit'));
+        }
+      }
+
+      // Dismiss collection
+      async function dismissCollection(collectionId) {
+        const res = await fetch('/admin/plugins/ai-search', {
+          method: 'POST',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({
+            dismissed_collections: [collectionId]
+          })
+        });
+        if (res.ok) {
+          location.reload();
+        }
+      }
+
+      // Re-index collection
+      async function reindexCollection(collectionId) {
+        const res = await fetch('/admin/plugins/ai-search/api/reindex', {
+          method: 'POST',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({ collection_id: collectionId })
+        });
+        if (res.ok) {
+          alert('Re-indexing started. Page will refresh in a moment.');
+          setTimeout(() => location.reload(), 2000);
+        } else {
+          alert('Failed to start re-indexing. Please try again.');
+        }
+      }
+
+      // Poll for index status updates
+      setInterval(async () => {
+        const res = await fetch('/admin/plugins/ai-search/api/status');
+        if (res.ok) {
+          const { data } = await res.json();
+          // Update status indicators if needed
+          // For now, just reload every 30 seconds if indexing is in progress
+          const hasIndexing = Object.values(data).some((s) => s.status === 'indexing');
+          if (hasIndexing) {
+            location.reload();
+          }
+        }
+      }, 30000);
+    </script>
+  `;
+  return renderAdminLayout({
+    title: "AI Search Settings",
+    pageTitle: "AI Search Settings",
+    currentPath: "/admin/plugins/ai-search/settings",
+    user: data.user,
+    content: content2
+  });
+}
+
+// src/plugins/core-plugins/ai-search-plugin/routes/admin.ts
+var adminRoutes = new Hono();
+adminRoutes.use("*", requireAuth());
+adminRoutes.get("/", async (c) => {
+  try {
+    const user = c.get("user");
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const indexer = new IndexManager(db, ai, vectorize);
+    const settings = await service.getSettings();
+    console.log("[AI Search Settings Route] Settings loaded:", !!settings);
+    const collections2 = await service.getAllCollections();
+    console.log("[AI Search Settings Route] Collections returned:", collections2.length);
+    if (collections2.length === 0) {
+      const directQuery = await db.prepare("SELECT id, name, display_name FROM collections WHERE is_active = 1").all();
+      console.log("[AI Search Settings Route] Direct DB query found:", directQuery.results?.length || 0, "collections");
+      if (directQuery.results && directQuery.results.length > 0) {
+        console.log("[AI Search Settings Route] Sample from DB:", directQuery.results[0]);
+      }
+    } else if (collections2.length > 0 && collections2[0]) {
+      console.log("[AI Search Settings Route] First collection:", {
+        id: collections2[0].id,
+        name: collections2[0].name,
+        display_name: collections2[0].display_name
+      });
+    }
+    const newCollections = await service.detectNewCollections();
+    console.log("AI Search: New collections:", newCollections.length);
+    const indexStatus = await indexer.getAllIndexStatus();
+    console.log("AI Search: Index status:", Object.keys(indexStatus).length);
+    const analytics = await service.getSearchAnalytics();
+    return c.html(
+      renderSettingsPage({
+        settings,
+        collections: collections2 || [],
+        newCollections: newCollections || [],
+        indexStatus: indexStatus || {},
+        analytics,
+        user: {
+          name: user.email,
+          email: user.email,
+          role: user.role
+        }
+      })
+    );
+  } catch (error) {
+    console.error("Error rendering AI Search settings:", error);
+    return c.html(`<p>Error loading settings: ${error instanceof Error ? error.message : String(error)}</p>`, 500);
+  }
+});
+adminRoutes.post("/", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const indexer = new IndexManager(db, ai, vectorize);
+    const body = await c.req.json();
+    console.log("[AI Search POST] Received body:", JSON.stringify(body, null, 2));
+    const currentSettings = await service.getSettings();
+    console.log("[AI Search POST] Current settings selected_collections:", currentSettings?.selected_collections);
+    const updatedSettings = {
+      enabled: body.enabled !== void 0 ? Boolean(body.enabled) : currentSettings?.enabled,
+      ai_mode_enabled: body.ai_mode_enabled !== void 0 ? Boolean(body.ai_mode_enabled) : currentSettings?.ai_mode_enabled,
+      selected_collections: Array.isArray(body.selected_collections) ? body.selected_collections.map(String) : currentSettings?.selected_collections || [],
+      dismissed_collections: Array.isArray(body.dismissed_collections) ? body.dismissed_collections.map(String) : currentSettings?.dismissed_collections || [],
+      autocomplete_enabled: body.autocomplete_enabled !== void 0 ? Boolean(body.autocomplete_enabled) : currentSettings?.autocomplete_enabled,
+      cache_duration: body.cache_duration ? Number(body.cache_duration) : currentSettings?.cache_duration,
+      results_limit: body.results_limit ? Number(body.results_limit) : currentSettings?.results_limit,
+      index_media: body.index_media !== void 0 ? Boolean(body.index_media) : currentSettings?.index_media
+    };
+    console.log("[AI Search POST] Updated settings selected_collections:", updatedSettings.selected_collections);
+    const collectionsChanged = JSON.stringify(updatedSettings.selected_collections) !== JSON.stringify(currentSettings?.selected_collections || []);
+    const saved = await service.updateSettings(updatedSettings);
+    console.log("[AI Search POST] Settings saved, selected_collections:", saved.selected_collections);
+    if (collectionsChanged && updatedSettings.selected_collections) {
+      console.log("[AI Search POST] Collections changed, starting background indexing");
+      c.executionCtx.waitUntil(
+        indexer.syncAll(updatedSettings.selected_collections).then(() => console.log("[AI Search POST] Background indexing completed")).catch((error) => console.error("[AI Search POST] Background indexing error:", error))
+      );
+    }
+    return c.json({ success: true, settings: saved });
+  } catch (error) {
+    console.error("Error updating AI Search settings:", error);
+    return c.json({ error: "Failed to update settings" }, 500);
+  }
+});
+adminRoutes.get("/api/settings", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const settings = await service.getSettings();
+    return c.json({ success: true, data: settings });
+  } catch (error) {
+    console.error("Error fetching settings:", error);
+    return c.json({ error: "Failed to fetch settings" }, 500);
+  }
+});
+adminRoutes.get("/api/new-collections", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const notifications = await service.detectNewCollections();
+    return c.json({ success: true, data: notifications });
+  } catch (error) {
+    console.error("Error detecting new collections:", error);
+    return c.json({ error: "Failed to detect new collections" }, 500);
+  }
+});
+adminRoutes.get("/api/status", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const indexer = new IndexManager(db, ai, vectorize);
+    const status = await indexer.getAllIndexStatus();
+    return c.json({ success: true, data: status });
+  } catch (error) {
+    console.error("Error fetching index status:", error);
+    return c.json({ error: "Failed to fetch status" }, 500);
+  }
+});
+adminRoutes.post("/api/reindex", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const indexer = new IndexManager(db, ai, vectorize);
+    const body = await c.req.json();
+    const collectionIdRaw = body.collection_id;
+    const collectionId = collectionIdRaw ? String(collectionIdRaw) : "";
+    if (!collectionId || collectionId === "undefined" || collectionId === "null") {
+      return c.json({ error: "collection_id is required" }, 400);
+    }
+    c.executionCtx.waitUntil(
+      indexer.indexCollection(collectionId).then(() => console.log(`[AI Search Reindex] Completed for collection ${collectionId}`)).catch((error) => console.error(`[AI Search Reindex] Error for collection ${collectionId}:`, error))
+    );
+    return c.json({ success: true, message: "Re-indexing started" });
+  } catch (error) {
+    console.error("Error starting re-index:", error);
+    return c.json({ error: "Failed to start re-indexing" }, 500);
+  }
+});
+var admin_default = adminRoutes;
+var apiRoutes = new Hono();
+apiRoutes.post("/", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const body = await c.req.json();
+    const query = {
+      query: body.query || "",
+      mode: body.mode || "keyword",
+      filters: body.filters || {},
+      limit: body.limit ? Number(body.limit) : void 0,
+      offset: body.offset ? Number(body.offset) : void 0
+    };
+    if (query.filters?.dateRange) {
+      if (typeof query.filters.dateRange.start === "string") {
+        query.filters.dateRange.start = new Date(query.filters.dateRange.start);
+      }
+      if (typeof query.filters.dateRange.end === "string") {
+        query.filters.dateRange.end = new Date(query.filters.dateRange.end);
+      }
+    }
+    const results = await service.search(query);
+    return c.json({
+      success: true,
+      data: results
+    });
+  } catch (error) {
+    console.error("Search error:", error);
+    return c.json(
+      {
+        success: false,
+        error: "Search failed",
+        message: error instanceof Error ? error.message : String(error)
+      },
+      500
+    );
+  }
+});
+apiRoutes.get("/suggest", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const query = c.req.query("q") || "";
+    if (!query || query.length < 2) {
+      return c.json({ success: true, data: [] });
+    }
+    const suggestions = await service.getSearchSuggestions(query);
+    return c.json({
+      success: true,
+      data: suggestions
+    });
+  } catch (error) {
+    console.error("Suggestions error:", error);
+    return c.json(
+      {
+        success: false,
+        error: "Failed to get suggestions"
+      },
+      500
+    );
+  }
+});
+apiRoutes.get("/analytics", async (c) => {
+  try {
+    const db = c.env.DB;
+    const ai = c.env.AI;
+    const vectorize = c.env.VECTORIZE_INDEX;
+    const service = new AISearchService(db, ai, vectorize);
+    const analytics = await service.getSearchAnalytics();
+    return c.json({
+      success: true,
+      data: analytics
+    });
+  } catch (error) {
+    console.error("Analytics error:", error);
+    return c.json(
+      {
+        success: false,
+        error: "Failed to get analytics"
+      },
+      500
+    );
+  }
+});
+var api_default2 = apiRoutes;
+
+// src/plugins/core-plugins/ai-search-plugin/manifest.json
+var manifest_default = {
+  name: "AI Search",
+  description: "Advanced search with Cloudflare AI Search. Full-text search, semantic search, and advanced filtering across all content collections.",
+  version: "1.0.0",
+  author: "SonicJS"};
+
+// src/plugins/core-plugins/ai-search-plugin/index.ts
+var aiSearchPlugin = new PluginBuilder({
+  name: manifest_default.name,
+  version: manifest_default.version,
+  description: manifest_default.description,
+  author: { name: manifest_default.author }
+}).metadata({
+  description: manifest_default.description,
+  author: { name: manifest_default.author }
+}).addService("aiSearch", AISearchService).addService("indexManager", IndexManager).addRoute("/admin/plugins/ai-search", admin_default).addRoute("/api/search", api_default2).build();
 var magicLinkRequestSchema = z.object({
   email: z.string().email("Valid email is required")
 });
@@ -2728,6 +4539,35 @@ function renderMagicLinkEmail(magicLink, expiryMinutes) {
 }
 createMagicLinkAuthPlugin();
 
+// src/assets/favicon.ts
+var faviconSvg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   version="1.1"
+   id="Layer_1"
+   x="0px"
+   y="0px"
+   viewBox="380 1300 257.89001 278.8855"
+   xml:space="preserve"
+   width="257.89001"
+   height="278.8855"
+   xmlns="http://www.w3.org/2000/svg">
+<g
+   id="g10"
+   transform="translate(-383.935,-60.555509)">
+	<g
+   id="g9">
+		<path
+   fill="#f1f2f2"
+   d="m 974.78,1398.211 c -5.016,6.574 -10.034,13.146 -15.048,19.721 -1.828,2.398 -3.657,4.796 -5.487,7.194 1.994,1.719 3.958,3.51 5.873,5.424 18.724,18.731 28.089,41.216 28.089,67.459 0,26.251 -9.366,48.658 -28.089,67.237 -18.731,18.579 -41.215,27.868 -67.459,27.868 -9.848,0 -19.156,-1.308 -27.923,-3.923 l -4.185,3.354 c -8.587,6.885 -17.154,13.796 -25.725,20.702 17.52,8.967 36.86,13.487 58.054,13.487 35.533,0 65.91,-12.608 91.124,-37.821 25.214,-25.215 37.821,-55.584 37.821,-91.125 0,-35.534 -12.607,-65.911 -37.821,-91.126 -3,-2.999 -6.078,-5.808 -9.224,-8.451 z"
+   id="path2" />
+		<path
+   fill="#34d399"
+   d="m 854.024,1585.195 20.001,-16.028 c 16.616,-13.507 33.04,-27.265 50.086,-40.251 1.13,-0.861 2.9,-1.686 2.003,-3.516 -0.843,-1.716 -2.481,-2.302 -4.484,-2.123 -8.514,0.765 -17.016,-0.538 -25.537,-0.353 -1.124,0.024 -2.768,0.221 -3.163,-1.25 -0.371,-1.369 1.088,-2.063 1.919,-2.894 6.26,-6.242 12.574,-12.43 18.816,-18.691 9.303,-9.327 18.565,-18.714 27.851,-28.066 1.848,-1.859 3.701,-3.713 5.549,-5.572 2.655,-2.661 5.309,-5.315 7.958,-7.982 0.574,-0.579 1.259,-1.141 1.246,-1.94 -0.004,-0.257 -0.078,-0.538 -0.254,-0.853 -0.556,-0.981 -1.441,-1.1 -2.469,-0.957 -0.658,0.096 -1.315,0.185 -1.973,0.275 -3.844,0.538 -7.689,1.076 -11.533,1.608 -3.641,0.505 -7.281,1.02 -10.922,1.529 -4.162,0.582 -8.324,1.158 -12.486,1.748 -1.142,0.161 -2.409,1.662 -3.354,0.508 -0.419,-0.508 -0.431,-1.028 -0.251,-1.531 0.269,-0.741 0.957,-1.441 1.387,-2.021 3.414,-4.58 6.882,-9.124 10.356,-13.662 1.74,-2.272 3.48,-4.544 5.214,-6.822 4.682,-6.141 9.369,-12.281 14.051,-18.422 0.09,-0.119 0.181,-0.237 0.271,-0.355 6.848,-8.98 13.7,-17.958 20.553,-26.936 0.488,-0.64 0.977,-1.28 1.465,-1.92 2.159,-2.828 4.315,-5.658 6.476,-8.486 4.197,-5.501 8.454,-10.954 12.67,-16.442 0.263,-0.347 0.538,-0.718 0.717,-1.106 0.269,-0.586 0.299,-1.196 -0.335,-1.776 -0.825,-0.753 -1.8,-0.15 -2.595,0.419 -0.67,0.472 -1.333,0.957 -1.955,1.489 -2.206,1.889 -4.401,3.797 -6.595,5.698 -3.958,3.438 -7.922,6.876 -11.976,10.194 -2.443,2.003 -4.865,4.028 -7.301,6.038 -18.689,-10.581 -39.53,-15.906 -62.549,-15.906 -35.54,0 -65.911,12.607 -91.125,37.82 -25.214,25.215 -37.821,55.592 -37.821,91.126 0,35.54 12.607,65.91 37.821,91.125 4.146,4.146 8.445,7.916 12.87,11.381 -9.015,11.14 -18.036,22.277 -27.034,33.429 -1.208,1.489 -3.755,3.151 -2.745,4.891 0.078,0.144 0.173,0.281 0.305,0.425 1.321,1.429 3.492,-1.303 4.933,-2.457 6.673,-5.333 13.333,-10.685 19.982,-16.042 3.707,-2.984 7.417,-5.965 11.124,-8.952 1.474,-1.188 2.951,-2.373 4.425,-3.561 6.41,-5.164 12.816,-10.333 19.238,-15.481 z m -56.472,-87.186 c 0,-26.243 9.29,-48.728 27.868,-67.459 18.579,-18.723 40.987,-28.089 67.238,-28.089 12.273,0 23.712,2.075 34.34,6.171 -3.37,2.905 -6.734,5.816 -10.069,8.762 -6.075,5.351 -12.365,10.469 -18.667,15.564 -4.179,3.378 -8.371,6.744 -12.514,10.164 -7.54,6.23 -15.037,12.52 -22.529,18.804 -7.091,5.955 -14.182,11.904 -21.19,17.949 -1.136,0.974 -3.055,1.907 -2.135,3.94 0.831,1.836 2.774,1.417 4.341,1.578 l 12.145,-0.599 14.151,-0.698 c 1.031,-0.102 2.192,-0.257 2.89,0.632 0.034,0.044 0.073,0.078 0.106,0.127 1.017,1.561 -0.67,2.105 -1.387,2.942 -6.308,7.318 -12.616,14.637 -18.978,21.907 -8.161,9.339 -16.353,18.649 -24.544,27.958 -2.146,2.433 -4.275,4.879 -6.422,7.312 -1.034,1.172 -2.129,2.272 -1.238,3.922 0.933,1.728 2.685,1.752 4.323,1.602 4.134,-0.367 8.263,-0.489 12.396,-0.492 0.242,0 0.485,-0.01 0.728,0 2.711,0.01 5.422,0.068 8.134,0.145 2.582,0.074 5.166,0.165 7.752,0.249 0.275,1.62 -0.879,2.356 -1.62,3.259 -1.333,1.626 -2.667,3.247 -4,4.867 -4.315,5.252 -8.62,10.514 -12.928,15.772 -3.562,-2.725 -7.007,-5.733 -10.324,-9.051 -18.577,-18.576 -27.867,-40.983 -27.867,-67.234 z"
+   id="path9" />
+	</g>
+</g>
+</svg>`;
+
 // src/app.ts
 function createSonicJSApp(config = {}) {
   const app = new Hono();
@@ -2739,7 +4579,6 @@ function createSonicJSApp(config = {}) {
   });
   app.use("*", metricsMiddleware());
   app.use("*", bootstrapMiddleware(config));
-  app.use("*", adminSetupMiddleware());
   if (config.middleware?.beforeAuth) {
     for (const middleware of config.middleware.beforeAuth) {
       app.use("*", middleware);
@@ -2767,6 +4606,11 @@ function createSonicJSApp(config = {}) {
   app.route("/admin/seed-data", createSeedDataAdminRoutes());
   app.route("/admin/content", admin_content_default);
   app.route("/admin/media", adminMediaRoutes);
+  if (aiSearchPlugin.routes && aiSearchPlugin.routes.length > 0) {
+    for (const route of aiSearchPlugin.routes) {
+      app.route(route.path, route.handler);
+    }
+  }
   app.route("/admin/plugins", adminPluginRoutes);
   app.route("/admin/logs", adminLogsRoutes);
   app.route("/admin", userRoutes);
@@ -2788,6 +4632,14 @@ function createSonicJSApp(config = {}) {
       app.route(route.path, route.handler);
     }
   }
+  app.get("/favicon.svg", (c) => {
+    return new Response(faviconSvg, {
+      headers: {
+        "Content-Type": "image/svg+xml",
+        "Cache-Control": "public, max-age=31536000"
+      }
+    });
+  });
   app.get("/files/*", async (c) => {
     try {
       const url = new URL(c.req.url);