squidclaw 0.1.0

package/lib/behavior/engine.js

@@ -0,0 +1,187 @@
+/**
+ * 🦑 Behavior Engine
+ * Makes AI responses feel human — splitting, reactions, emotion detection, etc.
+ */
+
+import { logger } from '../core/logger.js';
+
+export class BehaviorEngine {
+  constructor() {}
+
+  /**
+   * Process an AI response into human-like message chunks
+   * Returns: { messages: string[], reaction: string|null, memoryUpdates: object[], handoff: string|null }
+   */
+  process(rawResponse) {
+    const result = {
+      messages: [],
+      reaction: null,
+      memoryUpdates: [],
+      handoff: null,
+    };
+
+    let text = rawResponse;
+
+    // Extract reaction
+    const reactMatch = text.match(/---REACT:(.+?)---/);
+    if (reactMatch) {
+      result.reaction = reactMatch[1].trim();
+      text = text.replace(/---REACT:.+?---/g, '').trim();
+    }
+
+    // Extract memory updates
+    const memoryRegex = /---MEMORY:(.+?):(.+?)---/g;
+    let memMatch;
+    while ((memMatch = memoryRegex.exec(text)) !== null) {
+      result.memoryUpdates.push({ key: memMatch[1].trim(), value: memMatch[2].trim() });
+    }
+    text = text.replace(/---MEMORY:.+?:.+?---/g, '').trim();
+
+    // Extract handoff
+    const handoffMatch = text.match(/---HANDOFF:(.+?)---/);
+    if (handoffMatch) {
+      result.handoff = handoffMatch[1].trim();
+      text = text.replace(/---HANDOFF:.+?---/g, '').trim();
+    }
+
+    // Split messages
+    if (text) {
+      if (text.includes('---SPLIT---')) {
+        result.messages = text.split('---SPLIT---')
+          .map(s => s.trim())
+          .filter(s => s.length > 0);
+      } else {
+        // Auto-split long messages
+        result.messages = this._autoSplit(text);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Auto-split long text into natural message chunks
+   */
+  _autoSplit(text) {
+    // If short enough, return as-is
+    if (text.length <= 250) return [text];
+
+    const chunks = [];
+    const sentences = text.split(/(?<=[.!?،؟])\s+/);
+    let current = '';
+
+    for (const sentence of sentences) {
+      if ((current + ' ' + sentence).trim().length > 250 && current) {
+        chunks.push(current.trim());
+        current = sentence;
+      } else {
+        current = current ? current + ' ' + sentence : sentence;
+      }
+    }
+    if (current.trim()) chunks.push(current.trim());
+
+    // If we still have chunks that are too long, split by newlines
+    const final = [];
+    for (const chunk of chunks) {
+      if (chunk.length > 400) {
+        const lines = chunk.split('\n').filter(l => l.trim());
+        final.push(...lines);
+      } else {
+        final.push(chunk);
+      }
+    }
+
+    // Max 4 chunks
+    if (final.length > 4) {
+      return [
+        final.slice(0, 2).join(' '),
+        final.slice(2, 3).join(' '),
+        final.slice(3).join(' '),
+      ].filter(s => s.trim());
+    }
+
+    return final.length > 0 ? final : [text];
+  }
+
+  /**
+   * Detect the emotional tone of an incoming message
+   */
+  detectEmotion(text) {
+    const lower = text.toLowerCase();
+
+    // Angry indicators
+    const angryWords = ['!!', 'terrible', 'worst', 'awful', 'hate', 'angry', 'furious', 'unacceptable',
+      'زفت', 'سيء', 'أسوأ', 'غضب'];
+    if (angryWords.some(w => lower.includes(w)) || (text.match(/!/g) || []).length >= 2) {
+      return 'angry';
+    }
+
+    // Happy indicators
+    const happyWords = ['thank', 'love', 'amazing', 'great', 'awesome', 'perfect', 'excellent',
+      'شكر', 'ممتاز', 'رائع', 'حلو', '❤️', '😍', '🥰', '😊'];
+    if (happyWords.some(w => lower.includes(w))) {
+      return 'happy';
+    }
+
+    // Confused indicators
+    const confusedWords = ['don\'t understand', 'confused', 'what do you mean', 'how', 'explain',
+      'مش فاهم', 'كيف', 'وش يعني'];
+    if (confusedWords.some(w => lower.includes(w)) || text.includes('??')) {
+      return 'confused';
+    }
+
+    // Urgent indicators
+    const urgentWords = ['urgent', 'asap', 'immediately', 'emergency', 'now', 'hurry',
+      'ضروري', 'مستعجل', 'فوري', 'الحين'];
+    if (urgentWords.some(w => lower.includes(w))) {
+      return 'urgent';
+    }
+
+    return 'neutral';
+  }
+
+  /**
+   * Detect if a message is a conversation ending
+   */
+  isConversationEnding(text) {
+    const lower = text.toLowerCase().trim();
+    const endings = [
+      'ok', 'okay', 'thanks', 'thank you', 'thx', 'bye', 'goodbye', 'see you',
+      'good night', 'gn', 'ttyl', 'later', 'cool', 'got it', 'perfect',
+      'شكرا', 'مشكور', 'تمام', 'اوكي', 'باي', 'يعطيك العافية', 'الله يعافيك',
+      '👍', '🙏', '✅', '❤️', '👋',
+    ];
+    return endings.some(e => lower === e || lower === e + '!' || lower === e + '.');
+  }
+
+  /**
+   * Detect the language of a message
+   */
+  detectLanguage(text) {
+    // Check for Arabic characters
+    const arabicRegex = /[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]/;
+    const arabicChars = (text.match(arabicRegex) || []).length;
+    const totalChars = text.replace(/\s/g, '').length;
+
+    if (totalChars === 0) return 'en';
+    const arabicRatio = arabicChars / totalChars;
+
+    if (arabicRatio > 0.3) return 'ar';
+    return 'en';
+  }
+
+  /**
+   * Get appropriate reaction emoji for a message
+   */
+  suggestReaction(text, emotion) {
+    if (emotion === 'happy') return '❤️';
+    if (emotion === 'angry') return null; // don't react to angry messages
+    
+    const lower = text.toLowerCase();
+    if (lower.includes('😂') || lower.includes('haha') || lower.includes('lol')) return '😂';
+    if (lower.includes('photo') || lower.includes('image') || lower.includes('📸')) return '😍';
+    if (this.isConversationEnding(text)) return '❤️';
+
+    return null;
+  }
+}

package/lib/channels/hub-media.js

@@ -0,0 +1,128 @@
+/**
+ * 🦑 Channel Hub Media Extension
+ * Adds voice note transcription, image analysis, and voice reply support
+ */
+
+import { MediaHandler } from './whatsapp/media.js';
+import { logger } from '../core/logger.js';
+
+/**
+ * Enhance ChannelHub with media processing capabilities
+ */
+export function addMediaSupport(hub, config, home) {
+  const mediaHandler = new MediaHandler(config, home);
+  const originalHandler = hub._handleWhatsAppMessage.bind(hub);
+
+  hub._handleWhatsAppMessage = async function(agentId, contactId, message, metadata) {
+    const agent = hub.agentManager.get(agentId);
+    if (!agent) return;
+
+    // Handle voice notes — transcribe first
+    if (metadata.mediaType === 'audio' && metadata._rawMessage) {
+      logger.info('hub', `🎤 Voice note from ${contactId} — transcribing...`);
+      try {
+        const buffer = await hub.whatsappManager.downloadMedia(agentId, metadata._rawMessage);
+        if (buffer) {
+          const transcript = await mediaHandler.transcribeAudio(buffer, config);
+          if (transcript) {
+            message = `[🎤 Voice note transcription]: "${transcript}"`;
+            metadata.originalType = 'voice';
+            metadata.transcript = transcript;
+            logger.info('hub', `Transcribed: ${transcript.substring(0, 50)}...`);
+          }
+        }
+      } catch (err) {
+        logger.error('hub', `Transcription failed: ${err.message}`);
+      }
+    }
+
+    // Handle images — analyze with vision
+    if (metadata.mediaType === 'image' && metadata._rawMessage) {
+      logger.info('hub', `📸 Image from ${contactId} — analyzing...`);
+      try {
+        const buffer = await hub.whatsappManager.downloadMedia(agentId, metadata._rawMessage);
+        if (buffer) {
+          const caption = message.replace('[📸 Image]', '').trim();
+          const analysis = await mediaHandler.analyzeImage(buffer, caption || 'What is in this image? Be brief.', config);
+          message = caption
+            ? `[📸 Image with caption: "${caption}"]\nImage shows: ${analysis}`
+            : `[📸 Image]\nImage shows: ${analysis}`;
+          metadata.originalType = 'image';
+          metadata.imageAnalysis = analysis;
+        }
+      } catch (err) {
+        logger.error('hub', `Image analysis failed: ${err.message}`);
+      }
+    }
+
+    // Process message through agent (original flow)
+    if (metadata.isGroup) return;
+
+    const result = await agent.processMessage(contactId, message, metadata);
+
+    // Send reaction
+    if (result.reaction && metadata.messageId) {
+      try {
+        await hub.whatsappManager.sendReaction(agentId, contactId, metadata.messageId, result.reaction);
+      } catch {}
+    }
+
+    // Decide: send as voice note or text?
+    const behavior = agent.behavior || {};
+    const shouldVoice = _shouldSendVoice(behavior, result.messages, metadata);
+
+    if (shouldVoice && result.messages.length > 0) {
+      // Send as voice note
+      const fullText = result.messages.join('. ');
+      try {
+        const voiceConfig = behavior.voice || {};
+        // Auto-select Arabic voice if message is Arabic
+        if (!voiceConfig.name) {
+          const { BehaviorEngine } = await import('../behavior/engine.js');
+          const be = new BehaviorEngine();
+          const lang = be.detectLanguage(fullText);
+          voiceConfig.name = lang === 'ar' ? 'ar-SA-ZariyahNeural' : 'en-US-AriaNeural';
+        }
+        const audioBuffer = await mediaHandler.textToSpeech(fullText, voiceConfig);
+        if (audioBuffer) {
+          await hub.whatsappManager.sendVoiceNote(agentId, contactId, audioBuffer);
+          logger.info('hub', `🎤 Sent voice reply to ${contactId}`);
+        } else {
+          // Fallback to text
+          await hub.whatsappManager.sendMessages(agentId, contactId, result.messages);
+        }
+      } catch (err) {
+        logger.warn('hub', `Voice send failed, falling back to text: ${err.message}`);
+        await hub.whatsappManager.sendMessages(agentId, contactId, result.messages);
+      }
+    } else if (result.messages.length > 0) {
+      await hub.whatsappManager.sendMessages(agentId, contactId, result.messages);
+    }
+
+    // Handoff notification
+    if (result.handoff) {
+      await hub._notifyHandoff(agent, contactId, result.handoff, message);
+    }
+
+    // Webhooks
+    await hub._fireWebhooks('message', {
+      agentId, contactId, incomingMessage: message, replies: result.messages, usage: result.usage,
+    });
+  };
+}
+
+function _shouldSendVoice(behavior, messages, metadata) {
+  const voiceConfig = behavior.voice || {};
+  if (!voiceConfig.enabled) return false;
+
+  const mode = voiceConfig.sendVoice || 'never'; // never | sometimes | prefer
+  if (mode === 'never') return false;
+  if (mode === 'prefer') return true;
+
+  // 'sometimes' — send voice for long responses or when customer sent voice
+  if (metadata.originalType === 'voice') return true;
+  const totalLength = messages.join(' ').length;
+  if (voiceConfig.voiceForLong && totalLength > 500) return true;
+
+  return false;
+}

package/lib/channels/hub.js

@@ -0,0 +1,89 @@
+/**
+ * 🦑 Channel Hub
+ * Routes messages between channels and agents
+ */
+
+import { logger } from '../core/logger.js';
+
+export class ChannelHub {
+  constructor(agentManager, whatsappManager, storage) {
+    this.agentManager = agentManager;
+    this.whatsappManager = whatsappManager;
+    this.storage = storage;
+
+    // Wire up WhatsApp message handler
+    this.whatsappManager.onMessage = this._handleWhatsAppMessage.bind(this);
+  }
+
+  async _handleWhatsAppMessage(agentId, contactId, message, metadata) {
+    const agent = this.agentManager.get(agentId);
+    if (!agent) {
+      logger.warn('hub', `No agent found for ${agentId}`);
+      return;
+    }
+
+    // Skip group messages unless mentioned (for now)
+    if (metadata.isGroup) {
+      // TODO: implement group mention detection
+      return;
+    }
+
+    // Process message through agent
+    const result = await agent.processMessage(contactId, message, metadata);
+
+    // Send reaction first (if any)
+    if (result.reaction && metadata.messageId) {
+      try {
+        await this.whatsappManager.sendReaction(agentId, contactId, metadata.messageId, result.reaction);
+      } catch (err) {
+        logger.warn('hub', `Failed to send reaction: ${err.message}`);
+      }
+    }
+
+    // Send reply messages with human-like delays
+    if (result.messages.length > 0) {
+      try {
+        await this.whatsappManager.sendMessages(agentId, contactId, result.messages);
+      } catch (err) {
+        logger.error('hub', `Failed to send reply: ${err.message}`);
+      }
+    }
+
+    // Handle handoff notification
+    if (result.handoff) {
+      await this._notifyHandoff(agent, contactId, result.handoff, message);
+    }
+
+    // Fire webhooks
+    await this._fireWebhooks('message', {
+      agentId,
+      contactId,
+      incomingMessage: message,
+      replies: result.messages,
+      emotion: metadata.emotion,
+      usage: result.usage,
+    });
+  }
+
+  async _notifyHandoff(agent, contactId, reason, lastMessage) {
+    // TODO: notify agent owner via WhatsApp/push notification
+    logger.info('hub', `⚠️ HANDOFF: Agent "${agent.name}" needs help with ${contactId}. Reason: ${reason}`);
+  }
+
+  async _fireWebhooks(event, data) {
+    const webhooks = await this.storage.getWebhooks();
+    for (const wh of webhooks) {
+      if (wh.events.includes('*') || wh.events.includes(event)) {
+        try {
+          await fetch(wh.url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ event, data, timestamp: new Date().toISOString() }),
+          });
+        } catch (err) {
+          logger.warn('hub', `Webhook ${wh.id} failed: ${err.message}`);
+        }
+      }
+    }
+  }
+}