wu-framework 1.1.6 → 1.1.8

package/src/ai/wu-ai.js

@@ -0,0 +1,474 @@
+/**
+ * WU-AI: Central orchestrator for AI integration
+ *
+ * This is the main entry point for wu.ai — it wires together all sub-modules
+ * and exposes the public API. Lazy-initialized on first use.
+ *
+ * Architecture:
+ *   WuAI (this file)
+ *     ├── WuAIProvider      → BYOL provider management
+ *     ├── WuAIPermissions   → Security, rate limiting, circuit breaker
+ *     ├── WuAIContext        → Auto context collection for LLM
+ *     ├── WuAIActions        → Tool/action registry and execution
+ *     ├── WuAIConversation   → Multi-turn conversation manager
+ *     └── WuAITriggers       → Event-to-AI bridge (reactive AI)
+ *
+ * Public API (accessible via wu.ai):
+ *   wu.ai.provider(name, config)   → Register LLM provider
+ *   wu.ai.send(message, opts)      → Send message (non-streaming)
+ *   wu.ai.stream(message, opts)    → Send message (streaming)
+ *   wu.ai.action(name, config)     → Register an action/tool
+ *   wu.ai.trigger(name, config)    → Register an event trigger
+ *   wu.ai.context.configure(...)   → Configure context collection
+ *   wu.ai.abort(namespace?)        → Abort active request
+ *
+ * Paradigm 2 (External agent access):
+ *   wu.ai.tools()                  → Get all registered tools (for CDP/WebMCP)
+ *   wu.ai.execute(name, params)    → Execute action directly (for external agents)
+ *   wu.ai.expose()                 → Register tools via WebMCP (navigator.modelContext)
+ */
+
+import { logger } from '../core/wu-logger.js';
+import { WuAIProvider } from './wu-ai-provider.js';
+import { WuAIPermissions } from './wu-ai-permissions.js';
+import { WuAIContext } from './wu-ai-context.js';
+import { WuAIActions } from './wu-ai-actions.js';
+import { WuAIConversation } from './wu-ai-conversation.js';
+import { WuAITriggers } from './wu-ai-triggers.js';
+import { registerBrowserActions } from './wu-ai-browser.js';
+
+export class WuAI {
+  /**
+   * @param {object} deps - Injected from WuCore
+   * @param {object} deps.eventBus - WuEventBus instance
+   * @param {object} deps.store - WuStore instance
+   * @param {object} deps.core - WuCore instance (for mounted apps)
+   */
+  constructor({ eventBus, store, core }) {
+    this._eventBus = eventBus;
+    this._store = store;
+    this._core = core;
+    this._initialized = false;
+    this._modules = {};
+  }
+
+  // ─── Lazy Initialization ───────────────────────────────────────
+
+  /**
+   * Initialize all sub-modules. Called automatically on first use,
+   * or can be called explicitly with configuration.
+   *
+   * @param {object} [config]
+   * @param {object} [config.permissions] - Permission overrides
+   * @param {object} [config.rateLimit] - Rate limit config
+   * @param {object} [config.circuitBreaker] - Circuit breaker config
+   * @param {object} [config.loopProtection] - Loop protection config
+   * @param {object} [config.context] - Context collection config
+   * @param {object} [config.conversation] - Conversation defaults
+   * @param {object} [config.triggers] - Trigger system config
+   */
+  init(config = {}) {
+    if (this._initialized) {
+      // Reconfigure if already initialized
+      this._reconfigure(config);
+      return this;
+    }
+
+    // 1. Permissions (independent — no deps)
+    this._modules.permissions = new WuAIPermissions({
+      permissions: config.permissions,
+      rateLimit: config.rateLimit,
+      circuitBreaker: config.circuitBreaker,
+      loopProtection: config.loopProtection,
+      allowedDomains: config.allowedDomains,
+    });
+
+    // 2. Provider (independent — no deps)
+    this._modules.provider = new WuAIProvider();
+
+    // 3. Context (depends on store, eventBus, core)
+    this._modules.context = new WuAIContext({
+      store: this._store,
+      eventBus: this._eventBus,
+      core: this._core,
+    });
+    if (config.context) {
+      this._modules.context.configure(config.context);
+    }
+
+    // 4. Actions (depends on eventBus, store, permissions)
+    this._modules.actions = new WuAIActions({
+      eventBus: this._eventBus,
+      store: this._store,
+      permissions: this._modules.permissions,
+    });
+
+    // 5. Conversation (depends on provider, actions, context, permissions, eventBus)
+    this._modules.conversation = new WuAIConversation({
+      provider: this._modules.provider,
+      actions: this._modules.actions,
+      context: this._modules.context,
+      permissions: this._modules.permissions,
+      eventBus: this._eventBus,
+    });
+    if (config.conversation) {
+      this._modules.conversation.configure(config.conversation);
+    }
+
+    // 6. Triggers (depends on eventBus, conversation, permissions)
+    this._modules.triggers = new WuAITriggers({
+      eventBus: this._eventBus,
+      conversation: this._modules.conversation,
+      permissions: this._modules.permissions,
+    });
+    if (config.triggers) {
+      this._modules.triggers.configure(config.triggers);
+    }
+
+    this._initialized = true;
+    logger.wuInfo('[wu-ai] Initialized');
+
+    // 7. Browser automation actions (screenshot, click, type, network, etc.)
+    // Must be AFTER _initialized = true to prevent recursive init loop
+    if (typeof window !== 'undefined') {
+      registerBrowserActions(this, this._core);
+      logger.wuInfo('[wu-ai] Browser actions registered (10 tools)');
+    }
+
+    this._eventBus.emit('ai:initialized', {}, { appName: 'wu-ai' });
+
+    return this;
+  }
+
+  // ─── Provider Management ───────────────────────────────────────
+
+  /**
+   * Register an LLM provider.
+   *
+   * @param {string} name - Provider name ('openai', 'anthropic', 'ollama', or custom)
+   * @param {object} config - { endpoint, apiKey?, model?, adapter?, send?, stream? }
+   *
+   * @example
+   * // OpenAI via proxy (recommended)
+   * wu.ai.provider('openai', { endpoint: '/api/ai/chat', model: 'gpt-4o' });
+   *
+   * // Anthropic direct (development only)
+   * wu.ai.provider('anthropic', {
+   *   endpoint: 'https://api.anthropic.com/v1/messages',
+   *   apiKey: 'sk-...',
+   *   model: 'claude-sonnet-4-5-20250929',
+   * });
+   *
+   * // Local Ollama
+   * wu.ai.provider('ollama', { endpoint: 'http://localhost:11434/api/chat', model: 'llama3' });
+   *
+   * // Custom provider
+   * wu.ai.provider('my-llm', { send: async (messages, opts) => ({ content: '...' }) });
+   */
+  provider(name, config) {
+    this._ensureInit();
+    this._modules.provider.register(name, config);
+    return this;
+  }
+
+  // ─── Paradigm 1: App → LLM (Conversation) ─────────────────────
+
+  /**
+   * Send a message to the LLM and get a complete response.
+   *
+   * @param {string} message - User message
+   * @param {object} [options] - { namespace, systemPrompt, templateVars, temperature, maxTokens, signal }
+   * @returns {Promise<{ content: string, tool_results?: Array, usage?: object, namespace: string }>}
+   *
+   * @example
+   * const response = await wu.ai.send('What items are in the cart?');
+   * console.log(response.content);
+   *
+   * // With namespace for separate conversation
+   * const response = await wu.ai.send('Analyze this chart', { namespace: 'analytics' });
+   */
+  async send(message, options = {}) {
+    this._ensureInit();
+    return this._modules.conversation.send(message, options);
+  }
+
+  /**
+   * Send a message and stream the response.
+   *
+   * @param {string} message - User message
+   * @param {object} [options] - Same as send()
+   * @yields {{ type: 'text'|'tool_result'|'done'|'error', content?: string }}
+   *
+   * @example
+   * for await (const chunk of wu.ai.stream('Tell me about this page')) {
+   *   if (chunk.type === 'text') outputEl.textContent += chunk.content;
+   *   if (chunk.type === 'done') console.log('Done!');
+   * }
+   */
+  async *stream(message, options = {}) {
+    this._ensureInit();
+    yield* this._modules.conversation.stream(message, options);
+  }
+
+  /**
+   * Abort active request(s).
+   *
+   * @param {string} [namespace] - Specific namespace, or all if omitted
+   */
+  abort(namespace) {
+    if (!this._initialized) return;
+    if (namespace) {
+      this._modules.conversation.abort(namespace);
+    } else {
+      this._modules.conversation.abortAll();
+    }
+  }
+
+  // ─── Actions / Tools ───────────────────────────────────────────
+
+  /**
+   * Register an action that the LLM can call.
+   *
+   * @param {string} name - Action name (used in tool_call)
+   * @param {object} config - { description, parameters, handler, confirm?, permissions?, dangerous? }
+   *
+   * @example
+   * wu.ai.action('addToCart', {
+   *   description: 'Add an item to the shopping cart',
+   *   parameters: {
+   *     productId: { type: 'string', required: true },
+   *     quantity: { type: 'number' },
+   *   },
+   *   handler: async (params, api) => {
+   *     api.setState('cart.items', [...api.getState('cart.items'), params]);
+   *     api.emit('cart:updated', params);
+   *     return { added: params.productId };
+   *   },
+   *   confirm: true, // require user confirmation
+   * });
+   */
+  action(name, config) {
+    this._ensureInit();
+    this._modules.actions.register(name, config);
+    return this;
+  }
+
+  /**
+   * Execute an action directly (used by external agents via CDP/WebMCP).
+   *
+   * @param {string} name - Action name
+   * @param {object} params - Parameters
+   * @returns {Promise<{ success: boolean, result?: any, reason?: string }>}
+   */
+  async execute(name, params) {
+    this._ensureInit();
+    const traceId = this._modules.permissions.loopProtection.createTraceId();
+    return this._modules.actions.execute(name, params, { traceId, depth: 0 });
+  }
+
+  // ─── Triggers (Reactive AI) ────────────────────────────────────
+
+  /**
+   * Register a trigger that automatically sends messages to the LLM
+   * when specific events occur.
+   *
+   * @param {string} name - Trigger name
+   * @param {object} config - { pattern, prompt, condition?, debounce?, priority?, onResult? }
+   *
+   * @example
+   * wu.ai.trigger('cartAnalysis', {
+   *   pattern: 'cart:updated',
+   *   prompt: 'The cart was updated: {{data}}. Suggest complementary products.',
+   *   debounce: 3000,
+   *   priority: 'low',
+   *   onResult: (result) => {
+   *     wu.emit('ai:suggestions', { suggestions: result.content });
+   *   },
+   * });
+   */
+  trigger(name, config) {
+    this._ensureInit();
+    this._modules.triggers.register(name, config);
+    return this;
+  }
+
+  /**
+   * Fire a trigger manually.
+   */
+  async fireTrigger(name, eventData) {
+    this._ensureInit();
+    return this._modules.triggers.fire(name, eventData);
+  }
+
+  // ─── Context ───────────────────────────────────────────────────
+
+  /**
+   * Context configuration sub-API.
+   * Access via wu.ai.context
+   */
+  get context() {
+    this._ensureInit();
+    return {
+      configure: (config) => this._modules.context.configure(config),
+      register: (name, config) => this._modules.context.register(name, config),
+      collect: () => this._modules.context.collect(),
+      getSnapshot: () => this._modules.context.getSnapshot(),
+    };
+  }
+
+  // ─── Conversation Management ───────────────────────────────────
+
+  /**
+   * Conversation sub-API for direct history management.
+   */
+  get conversation() {
+    this._ensureInit();
+    return {
+      getHistory: (ns) => this._modules.conversation.getHistory(ns),
+      clear: (ns) => this._modules.conversation.clear(ns),
+      clearAll: () => this._modules.conversation.clearAll(),
+      inject: (role, content, opts) => this._modules.conversation.inject(role, content, opts),
+      getNamespaces: () => this._modules.conversation.getNamespaces(),
+      deleteNamespace: (ns) => this._modules.conversation.deleteNamespace(ns),
+    };
+  }
+
+  // ─── Permissions ───────────────────────────────────────────────
+
+  /**
+   * Permissions sub-API.
+   */
+  get permissions() {
+    this._ensureInit();
+    return {
+      configure: (config) => this._modules.permissions.configure(config),
+      check: (perm) => this._modules.permissions.check(perm),
+      getPermissions: () => this._modules.permissions.getPermissions(),
+      setAllowedDomains: (domains) => this._modules.permissions.setAllowedDomains(domains),
+    };
+  }
+
+  // ─── Paradigm 2: LLM → App (External Agent Access) ────────────
+
+  /**
+   * Get all registered tools (for external agents).
+   * An agent connected via CDP can call: window.wu.ai.tools()
+   *
+   * @returns {Array<{ name, description, parameters }>}
+   */
+  tools() {
+    this._ensureInit();
+    return this._modules.actions.getToolSchemas();
+  }
+
+  /**
+   * Expose tools via WebMCP (Chrome 146+ / W3C proposal).
+   * Registers all actions with navigator.modelContext.registerTool()
+   *
+   * @returns {boolean} Whether WebMCP is available
+   */
+  expose() {
+    this._ensureInit();
+
+    if (typeof navigator === 'undefined' || !navigator.modelContext) {
+      logger.wuDebug('[wu-ai] WebMCP not available (navigator.modelContext missing)');
+      return false;
+    }
+
+    const tools = this._modules.actions.getToolSchemas();
+    const actionNames = this._modules.actions.getNames();
+
+    for (let i = 0; i < tools.length; i++) {
+      const tool = tools[i];
+      const actionName = actionNames[i];
+
+      try {
+        navigator.modelContext.registerTool({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.parameters,
+          handler: async (params) => {
+            const result = await this.execute(actionName, params);
+            return result.success ? result.result : { error: result.reason };
+          },
+        });
+      } catch (err) {
+        logger.wuDebug(`[wu-ai] WebMCP register failed for '${tool.name}': ${err.message}`);
+      }
+    }
+
+    logger.wuInfo(`[wu-ai] Exposed ${tools.length} tools via WebMCP`);
+
+    this._eventBus.emit('ai:webmcp:exposed', {
+      toolCount: tools.length,
+      tools: tools.map(t => t.name),
+    }, { appName: 'wu-ai' });
+
+    return true;
+  }
+
+  /**
+   * Confirm a pending tool call (for UI integration).
+   */
+  confirmTool(callId) {
+    if (!this._initialized) return;
+    this._modules.actions.confirmTool(callId);
+  }
+
+  /**
+   * Reject a pending tool call.
+   */
+  rejectTool(callId) {
+    if (!this._initialized) return;
+    this._modules.actions.rejectTool(callId);
+  }
+
+  // ─── Stats & Debug ─────────────────────────────────────────────
+
+  getStats() {
+    if (!this._initialized) return { initialized: false };
+
+    return {
+      initialized: true,
+      provider: this._modules.provider.getStats(),
+      permissions: this._modules.permissions.getStats(),
+      context: this._modules.context.getStats(),
+      actions: this._modules.actions.getStats(),
+      conversation: this._modules.conversation.getStats(),
+      triggers: this._modules.triggers.getStats(),
+    };
+  }
+
+  /**
+   * Destroy the AI system and clean up all resources.
+   */
+  destroy() {
+    if (!this._initialized) return;
+
+    this._modules.conversation.abortAll();
+    this._modules.triggers.destroy();
+    this._modules = {};
+    this._initialized = false;
+
+    logger.wuInfo('[wu-ai] Destroyed');
+    this._eventBus.emit('ai:destroyed', {}, { appName: 'wu-ai' });
+  }
+
+  // ─── Private ───────────────────────────────────────────────────
+
+  _ensureInit() {
+    if (!this._initialized) {
+      this.init();
+    }
+  }
+
+  _reconfigure(config) {
+    if (config.permissions) this._modules.permissions.configure(config.permissions);
+    if (config.rateLimit) this._modules.permissions.rateLimiter.configure(config.rateLimit);
+    if (config.circuitBreaker) this._modules.permissions.circuitBreaker.configure(config.circuitBreaker);
+    if (config.loopProtection) this._modules.permissions.loopProtection.configure(config.loopProtection);
+    if (config.context) this._modules.context.configure(config.context);
+    if (config.conversation) this._modules.conversation.configure(config.conversation);
+    if (config.triggers) this._modules.triggers.configure(config.triggers);
+  }
+}

package/src/core/wu-app.js

@@ -17,6 +17,7 @@ export class WuApp {
     this.name = name
     this.url = config.url
     this.container = config.container
+    this.keepAlive = config.keepAlive || false
     this._wu = wu
     this._mounted = false
     this._autoInit = config.autoInit !== false // Default true
@@ -33,10 +34,10 @@ export class WuApp {
    */
   _registerApp() {
     if (!this._wu.apps.has(this.name)) {
-      // Usar el método interno de wu-framework para registrar
       this._wu.apps.set(this.name, {
         name: this.name,
         url: this.url,
+        keepAlive: this.keepAlive,
         status: 'registered'
       })
       console.log(`📦 App registered: ${this.name} at ${this.url}`)
@@ -56,7 +57,7 @@ export class WuApp {
     }
 
     // Asegurar que wu-framework está inicializado
-    if (!this._wu.initialized) {
+    if (!this._wu.isInitialized) {
       await this._wu.init({
         apps: [{ name: this.name, url: this.url }]
       })
@@ -70,18 +71,51 @@ export class WuApp {
   }
 
   /**
-   * Desmontar la app
-   * @returns {Promise<void>}
+   * Desmontar la app.
+   * If keepAlive is configured, hides instead of destroying.
+   *
+   * @param {Object} [options] - { keepAlive, force }
+   * @returns {Promise<WuApp>}
    */
-  async unmount() {
+  async unmount(options = {}) {
+    if (!this._mounted && !this._wu.isHidden(this.name)) {
+      console.warn(`⚠️ App ${this.name} is not mounted`)
+      return this
+    }
+
+    await this._wu.unmount(this.name, options)
+    this._mounted = !this._wu.isHidden(this.name)
+
+    return this
+  }
+
+  /**
+   * Hide the app (keep-alive). Preserves all state for instant re-show.
+   * @returns {Promise<WuApp>}
+   */
+  async hide() {
     if (!this._mounted) {
       console.warn(`⚠️ App ${this.name} is not mounted`)
       return this
     }
 
-    await this._wu.unmount(this.name)
+    await this._wu.hide(this.name)
     this._mounted = false
+    return this
+  }
 
+  /**
+   * Show a hidden (keep-alive) app instantly.
+   * @returns {Promise<WuApp>}
+   */
+  async show() {
+    if (!this._wu.isHidden(this.name)) {
+      console.warn(`⚠️ App ${this.name} is not in keep-alive state`)
+      return this
+    }
+
+    await this._wu.show(this.name)
+    this._mounted = true
     return this
   }
 
@@ -91,7 +125,7 @@ export class WuApp {
    * @returns {Promise<void>}
    */
   async remount(container) {
-    await this.unmount()
+    await this.unmount({ force: true })
     await this.mount(container)
     return this
   }
@@ -104,6 +138,14 @@ export class WuApp {
     return this._mounted && this._wu.mounted?.has(this.name)
   }
 
+  /**
+   * Check if the app is in keep-alive (hidden) state
+   * @returns {boolean}
+   */
+  get isHidden() {
+    return this._wu.isHidden(this.name)
+  }
+
   /**
    * Obtener información de la app
    * @returns {Object}
@@ -184,7 +226,7 @@ export class WuApp {
    * Destruir la app completamente
    */
   async destroy() {
-    await this.unmount()
+    await this.unmount({ force: true })
     this._wu.apps.delete(this.name)
     this._mounted = false
     console.log(`🗑️ App destroyed: ${this.name}`)

package/src/core/wu-cache.js

@@ -346,8 +346,8 @@ export class WuCache {
    * @param {Object} entry - Entrada
    */
   saveToStorage(key, entry) {
+    const storage = this.getStorage();
     try {
-      const storage = this.getStorage();
       storage.setItem(`wu_cache_${key}`, JSON.stringify(entry));
     } catch (error) {
       // Storage lleno, limpiar entradas antiguas