@astermind/cybernetic-chatbot-client 2.2.21 → 2.2.34

package/dist/cybernetic-chatbot-client.esm.js

@@ -641,6 +641,10 @@ class CyberneticLocalRAG {
         // Tokenize and build document frequency
         const docFreq = new Map();
         for (const doc of documents) {
+            // Skip documents without content
+            if (!doc.content) {
+                continue;
+            }
             const tokens = this.tokenize(doc.content);
             const uniqueTokens = new Set(tokens);
             // Count document frequency
@@ -791,6 +795,9 @@ class CyberneticLocalRAG {
      * Tokenize text into words
      */
     tokenize(text) {
+        if (!text || typeof text !== 'string') {
+            return [];
+        }
         return text
             .toLowerCase()
             .replace(/[^\w\s]/g, ' ')
@@ -2663,6 +2670,68 @@ const configLoaders = {
 
 // src/agentic/SiteMapDiscovery.ts
 // Multi-source sitemap discovery and merging for agentic navigation
+// Zero-config mode: automatically discovers routes on any site
+// ==================== SMART DEFAULTS ====================
+/**
+ * Comprehensive default selectors that work on most sites
+ * Covers semantic HTML, common CSS patterns, and framework conventions
+ */
+const DEFAULT_NAV_SELECTORS = [
+    // Semantic HTML5 navigation
+    'nav a[href]',
+    '[role="navigation"] a[href]',
+    'header a[href]',
+    // Common CSS class patterns
+    '.nav a[href]',
+    '.navbar a[href]',
+    '.navigation a[href]',
+    '.sidebar a[href]',
+    '.side-nav a[href]',
+    '.sidenav a[href]',
+    '.menu a[href]',
+    '.main-menu a[href]',
+    '.top-menu a[href]',
+    // Data attributes
+    '[data-nav] a[href]',
+    '[data-menu] a[href]',
+    '[data-navigation] a[href]',
+    // ARIA patterns
+    '[aria-label*="navigation" i] a[href]',
+    '[aria-label*="menu" i] a[href]',
+    // Breadcrumbs
+    '[aria-label*="breadcrumb" i] a[href]',
+    '.breadcrumb a[href]',
+    '.breadcrumbs a[href]',
+    // Generic internal links (fallback - caught last)
+    'a[href^="/"]',
+];
+/**
+ * Default paths to exclude from discovery
+ * Covers common auth, API, and framework-internal routes
+ */
+const DEFAULT_EXCLUDE_PATTERNS = [
+    // Authentication routes
+    '/login', '/logout', '/signin', '/signout', '/sign-in', '/sign-out',
+    '/register', '/signup', '/sign-up', '/forgot-password', '/reset-password',
+    '/auth/*', '/oauth/*', '/callback/*', '/sso/*',
+    // API and framework internals
+    '/api/*', '/_next/*', '/_nuxt/*', '/__*',
+    // Special links
+    'javascript:*', 'mailto:*', 'tel:*', '#*',
+];
+/**
+ * Default maximum number of links to scan from DOM
+ * Prevents performance issues on sites with many links
+ */
+const DEFAULT_MAX_DOM_LINKS = 200;
+/**
+ * Default cache TTL for localStorage (5 minutes)
+ */
+const DEFAULT_CACHE_TTL = 5 * 60 * 1000;
+/**
+ * Cache version - increment when cache format changes
+ */
+const CACHE_VERSION = '1';
 /**
  * Multi-source sitemap discovery and management
  *
@@ -2670,6 +2739,9 @@ const configLoaders = {
  * 1. Static props (explicit configuration)
  * 2. Framework auto-discovery (React Router, Vue Router, etc.)
  * 3. Backend API (tenant-specific sitemaps)
+ *
+ * Zero-config mode: When agentic is enabled but no siteMapConfig provided,
+ * automatically discovers routes using smart defaults.
  */
 class SiteMapDiscovery {
     constructor(config, apiUrl, apiKey) {
@@ -2679,6 +2751,8 @@ class SiteMapDiscovery {
         this.backendCache = null;
         this.isInitialized = false;
         this.initPromise = null;
+        this.detectedFramework = 'generic';
+        this.popstateHandler = null;
         this.config = config;
         this.apiUrl = apiUrl;
         this.apiKey = apiKey;
@@ -2687,6 +2761,7 @@ class SiteMapDiscovery {
             this.staticEntries = this.enhanceEntries(config.static, 'props');
         }
     }
+    // ==================== INITIALIZATION ====================
     /**
      * Initialize all sitemap sources
      * Call this during widget initialization or first query based on loadStrategy
@@ -2701,8 +2776,19 @@ class SiteMapDiscovery {
         this.isInitialized = true;
     }
     async performInitialization() {
+        // Wait for DOM to be ready before discovery
+        await this.waitForDOMReady();
+        // Try to load from localStorage cache first
+        const cachedEntries = this.loadFromLocalStorage();
+        if (cachedEntries) {
+            this.discoveredEntries = cachedEntries;
+            console.log(`[SiteMapDiscovery] Loaded ${cachedEntries.length} entries from cache`);
+            // Still run discovery in background to refresh cache
+            this.refreshInBackground();
+            return;
+        }
         const tasks = [];
-        // Source 2: Framework auto-discovery
+        // Source 2: Framework auto-discovery (enabled by default)
         if (this.config.discovery?.enabled !== false) {
             tasks.push(this.discoverFromFramework());
         }
@@ -2716,6 +2802,8 @@ class SiteMapDiscovery {
                 const { entries, source } = result.value;
                 if (source === 'discovery') {
                     this.discoveredEntries = entries;
+                    // Save to localStorage
+                    this.saveToLocalStorage(entries);
                 }
                 else if (source === 'backend') {
                     this.backendEntries = entries;
@@ -2725,9 +2813,144 @@ class SiteMapDiscovery {
                 console.warn('[SiteMapDiscovery] Source failed:', result.reason);
             }
         }
+        // Set up popstate listener for SPA navigation
+        this.setupPopstateListener();
         const total = this.staticEntries.length + this.discoveredEntries.length + this.backendEntries.length;
         console.log(`[SiteMapDiscovery] Initialized with ${total} total entries (${this.staticEntries.length} static, ${this.discoveredEntries.length} discovered, ${this.backendEntries.length} backend)`);
     }
+    /**
+     * Wait for DOM to be ready before scanning
+     */
+    async waitForDOMReady() {
+        if (typeof document === 'undefined')
+            return;
+        if (document.readyState === 'complete' || document.readyState === 'interactive') {
+            // DOM is ready, but give frameworks a microtask to mount
+            await new Promise(resolve => setTimeout(resolve, 0));
+            return;
+        }
+        return new Promise((resolve) => {
+            document.addEventListener('DOMContentLoaded', () => resolve(), { once: true });
+        });
+    }
+    /**
+     * Set up popstate listener to re-discover on SPA navigation
+     */
+    setupPopstateListener() {
+        if (typeof window === 'undefined')
+            return;
+        this.popstateHandler = () => {
+            // Debounce re-discovery
+            setTimeout(() => {
+                this.refreshInBackground();
+            }, 100);
+        };
+        window.addEventListener('popstate', this.popstateHandler);
+    }
+    /**
+     * Refresh discovery in background without blocking
+     */
+    async refreshInBackground() {
+        try {
+            const result = await this.discoverFromFramework();
+            if (result.entries.length > 0) {
+                this.discoveredEntries = result.entries;
+                this.saveToLocalStorage(result.entries);
+            }
+        }
+        catch (error) {
+            // Silent fail for background refresh
+            console.debug('[SiteMapDiscovery] Background refresh failed:', error);
+        }
+    }
+    // ==================== LOCALSTORAGE CACHING ====================
+    /**
+     * Get localStorage cache key for current origin
+     */
+    getCacheKey() {
+        if (typeof window === 'undefined')
+            return 'astermind-sitemap';
+        return `astermind-sitemap-${window.location.origin}`;
+    }
+    /**
+     * Load discovered entries from localStorage cache
+     */
+    loadFromLocalStorage() {
+        if (typeof localStorage === 'undefined')
+            return null;
+        try {
+            const key = this.getCacheKey();
+            const cached = localStorage.getItem(key);
+            if (!cached)
+                return null;
+            const data = JSON.parse(cached);
+            // Check version
+            if (data.version !== CACHE_VERSION) {
+                localStorage.removeItem(key);
+                return null;
+            }
+            // Check TTL
+            const ttl = this.config.discovery?.cacheTtl ?? DEFAULT_CACHE_TTL;
+            if (Date.now() - data.timestamp > ttl) {
+                localStorage.removeItem(key);
+                return null;
+            }
+            this.detectedFramework = data.framework;
+            return data.entries;
+        }
+        catch (error) {
+            console.debug('[SiteMapDiscovery] Failed to load from cache:', error);
+            return null;
+        }
+    }
+    /**
+     * Save discovered entries to localStorage cache
+     */
+    saveToLocalStorage(entries) {
+        if (typeof localStorage === 'undefined')
+            return;
+        if (this.config.discovery?.cacheRoutes === false)
+            return;
+        try {
+            const key = this.getCacheKey();
+            const data = {
+                entries,
+                url: typeof window !== 'undefined' ? window.location.href : '',
+                timestamp: Date.now(),
+                framework: this.detectedFramework,
+                version: CACHE_VERSION
+            };
+            localStorage.setItem(key, JSON.stringify(data));
+        }
+        catch (error) {
+            // localStorage might be full or disabled
+            console.debug('[SiteMapDiscovery] Failed to save to cache:', error);
+        }
+    }
+    /**
+     * Clear localStorage cache
+     */
+    clearCache() {
+        if (typeof localStorage === 'undefined')
+            return;
+        localStorage.removeItem(this.getCacheKey());
+    }
+    // ==================== CLEANUP ====================
+    /**
+     * Dispose of resources (event listeners, etc.)
+     */
+    dispose() {
+        if (this.popstateHandler && typeof window !== 'undefined') {
+            window.removeEventListener('popstate', this.popstateHandler);
+            this.popstateHandler = null;
+        }
+    }
+    /**
+     * Get detected framework name
+     */
+    getDetectedFramework() {
+        return this.detectedFramework;
+    }
     /**
      * Get merged sitemap entries with deduplication
      */
@@ -2754,6 +2977,7 @@ class SiteMapDiscovery {
         try {
             // Detect framework if not specified
             const framework = config.framework || this.detectFramework();
+            this.detectedFramework = framework;
             let routes = [];
             switch (framework) {
                 case 'react-router':
@@ -2937,26 +3161,31 @@ class SiteMapDiscovery {
     }
     /**
      * Discover routes by scanning DOM navigation elements
+     * Uses smart defaults when no selectors provided
      */
     discoverFromDOM(selectors) {
         const routes = [];
         if (typeof document === 'undefined')
             return routes;
-        const defaultSelectors = [
-            'nav a[href]',
-            '[role="navigation"] a[href]',
-            '.nav a[href]',
-            '.navigation a[href]',
-            '.sidebar a[href]',
-            '.menu a[href]',
-            'header a[href]'
-        ];
-        const allSelectors = selectors || defaultSelectors;
+        // Use provided selectors or smart defaults
+        const allSelectors = selectors || DEFAULT_NAV_SELECTORS;
+        // Get max links limit from config or use default
+        const maxLinks = this.config.discovery?.maxDomLinks ?? DEFAULT_MAX_DOM_LINKS;
+        // Get exclude patterns (merge user-provided with defaults)
+        const userExcludes = this.config.discovery?.excludePaths || [];
+        const allExcludes = [...DEFAULT_EXCLUDE_PATTERNS, ...userExcludes];
         const seen = new Set();
+        let linkCount = 0;
         for (const selector of allSelectors) {
+            // Stop if we've hit the limit
+            if (linkCount >= maxLinks)
+                break;
             try {
                 const links = document.querySelectorAll(selector);
                 for (const link of links) {
+                    // Stop if we've hit the limit
+                    if (linkCount >= maxLinks)
+                        break;
                     const href = link.getAttribute('href');
                     if (!href)
                         continue;
@@ -2965,14 +3194,31 @@ class SiteMapDiscovery {
                         continue;
                     }
                     // Normalize path
-                    const path = href.startsWith('/') ? href : `/${href}`;
-                    // Skip duplicates, anchors, and special links
-                    if (seen.has(path) || path.startsWith('/#') || path === '/' || path.includes('javascript:')) {
-                        continue;
+                    let path = href;
+                    if (href.startsWith('http')) {
+                        try {
+                            path = new URL(href).pathname;
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    else if (!href.startsWith('/')) {
+                        path = `/${href}`;
                     }
-                    seen.add(path);
                     // Clean path (remove query string and hash)
                     const cleanPath = path.split('?')[0].split('#')[0];
+                    // Skip duplicates
+                    if (seen.has(cleanPath))
+                        continue;
+                    // Skip root path
+                    if (cleanPath === '/')
+                        continue;
+                    // Skip paths matching exclude patterns
+                    if (this.shouldExcludeRoute(cleanPath, allExcludes))
+                        continue;
+                    seen.add(cleanPath);
+                    linkCount++;
                     routes.push({
                         path: cleanPath,
                         name: link.textContent?.trim() || this.pathToName(cleanPath)
@@ -2983,6 +3229,7 @@ class SiteMapDiscovery {
                 // Invalid selector - skip
             }
         }
+        console.log(`[SiteMapDiscovery] DOM scan found ${routes.length} routes (limit: ${maxLinks})`);
         return routes;
     }
     // ==================== SOURCE 3: BACKEND API ====================
@@ -3270,9 +3517,18 @@ class CyberneticIntentClassifier {
         this.modalIndex = new Map();
         // Build indexes for fast lookup
         this.buildIndexes();
-        // Initialize multi-source sitemap discovery if configured
-        if (config.siteMapConfig) {
-            this.siteMapDiscovery = new SiteMapDiscovery(config.siteMapConfig, apiUrl, apiKey);
+        // Auto-enable sitemap discovery when agentic is enabled but no explicit config provided
+        // This enables zero-config mode: just set enabled: true and discovery works automatically
+        const siteMapConfig = config.siteMapConfig ?? (config.enabled && !config.siteMap?.length
+            ? { discovery: { enabled: true } }
+            : undefined);
+        // Initialize multi-source sitemap discovery
+        if (siteMapConfig) {
+            this.siteMapDiscovery = new SiteMapDiscovery(siteMapConfig, apiUrl, apiKey);
+            // Log zero-config mode activation
+            if (!config.siteMapConfig && config.enabled) {
+                console.log('[CyberneticIntentClassifier] Zero-config mode: auto-discovery enabled');
+            }
         }
     }
     /**