@astermind/cybernetic-chatbot-client 2.2.21 → 2.2.34

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

@@ -643,6 +643,10 @@
             // 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
@@ -793,6 +797,9 @@
          * Tokenize text into words
          */
         tokenize(text) {
+            if (!text || typeof text !== 'string') {
+                return [];
+            }
             return text
                 .toLowerCase()
                 .replace(/[^\w\s]/g, ' ')
@@ -2665,6 +2672,68 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
 
     // 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
      *
@@ -2672,6 +2741,9 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
      * 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) {
@@ -2681,6 +2753,8 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
             this.backendCache = null;
             this.isInitialized = false;
             this.initPromise = null;
+            this.detectedFramework = 'generic';
+            this.popstateHandler = null;
             this.config = config;
             this.apiUrl = apiUrl;
             this.apiKey = apiKey;
@@ -2689,6 +2763,7 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                 this.staticEntries = this.enhanceEntries(config.static, 'props');
             }
         }
+        // ==================== INITIALIZATION ====================
         /**
          * Initialize all sitemap sources
          * Call this during widget initialization or first query based on loadStrategy
@@ -2703,8 +2778,19 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
             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());
             }
@@ -2718,6 +2804,8 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                     const { entries, source } = result.value;
                     if (source === 'discovery') {
                         this.discoveredEntries = entries;
+                        // Save to localStorage
+                        this.saveToLocalStorage(entries);
                     }
                     else if (source === 'backend') {
                         this.backendEntries = entries;
@@ -2727,9 +2815,144 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                     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
          */
@@ -2756,6 +2979,7 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
             try {
                 // Detect framework if not specified
                 const framework = config.framework || this.detectFramework();
+                this.detectedFramework = framework;
                 let routes = [];
                 switch (framework) {
                     case 'react-router':
@@ -2939,26 +3163,31 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
         }
         /**
          * 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;
@@ -2967,14 +3196,31 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                             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)
@@ -2985,6 +3231,7 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
                     // Invalid selector - skip
                 }
             }
+            console.log(`[SiteMapDiscovery] DOM scan found ${routes.length} routes (limit: ${maxLinks})`);
             return routes;
         }
         // ==================== SOURCE 3: BACKEND API ====================
@@ -3272,9 +3519,18 @@ LJ5AZXvOhHaXdHzMuYKX5BpK4w7TqbPvJ6QPvKmLKvHh1VKcUJ6mJQgJJw==
             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');
+                }
             }
         }
         /**