squidclaw 0.1.0

package/lib/cli/tui.js

@@ -0,0 +1,308 @@
+/**
+ * 🦑 Squidclaw TUI
+ * Beautiful terminal chat interface — zero extra dependencies
+ */
+
+import { createInterface } from 'readline';
+import chalk from 'chalk';
+import { loadConfig, getHome } from '../core/config.js';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const ESC = '\x1b[';
+const CLEAR_SCREEN = `${ESC}2J${ESC}H`;
+const HIDE_CURSOR = `${ESC}?25l`;
+const SHOW_CURSOR = `${ESC}?25h`;
+const SAVE_CURSOR = `${ESC}s`;
+const RESTORE_CURSOR = `${ESC}u`;
+
+export async function tui(opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+
+  // Check engine
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/health`);
+    if (!res.ok) throw new Error();
+  } catch {
+    console.log(chalk.red('Engine not running. Start with: squidclaw start'));
+    return;
+  }
+
+  // Get agents
+  let agents = [];
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents`);
+    agents = await res.json();
+  } catch {}
+
+  if (agents.length === 0) {
+    console.log(chalk.red('No agents found. Create one: squidclaw agent create'));
+    return;
+  }
+
+  // Select agent
+  let currentAgent = agents.find(a => a.id === opts.agent) || agents[0];
+  let currentModel = currentAgent.model || config.ai?.defaultModel || 'unknown';
+
+  // State
+  const messages = [];
+  let totalTokens = 0;
+  let totalCost = 0;
+  let status = 'idle';
+  let inputBuffer = '';
+
+  // Load history
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${currentAgent.id}/history?contactId=tui&limit=20`);
+    const history = await res.json();
+    for (const msg of history) {
+      messages.push({ role: msg.role, content: msg.content, time: msg.created_at });
+    }
+  } catch {}
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    prompt: '',
+  });
+
+  // Enable raw mode for better key handling
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+
+  function getTermSize() {
+    return {
+      cols: process.stdout.columns || 80,
+      rows: process.stdout.rows || 24,
+    };
+  }
+
+  function render() {
+    const { cols, rows } = getTermSize();
+    const headerHeight = 3;
+    const footerHeight = 3;
+    const inputHeight = 1;
+    const chatHeight = rows - headerHeight - footerHeight - inputHeight - 2;
+
+    let output = '';
+
+    // Header
+    const waIcon = currentAgent.whatsappConnected ? chalk.green('📱') : chalk.gray('📱');
+    const title = `🦑 Squidclaw TUI`;
+    const agentInfo = `Agent: ${currentAgent.name}`;
+    const modelInfo = currentModel;
+    const header = ` ${title}  │  ${agentInfo}  │  ${modelInfo}  │  ${waIcon}`;
+
+    output += CLEAR_SCREEN;
+    output += chalk.bgCyan.black(' '.repeat(cols)) + '\n';
+    output += chalk.bgCyan.black(header.padEnd(cols)) + '\n';
+    output += chalk.bgCyan.black(' '.repeat(cols)) + '\n';
+
+    // Chat area
+    const visibleMessages = getVisibleMessages(chatHeight, cols);
+    for (let i = 0; i < chatHeight; i++) {
+      if (i < visibleMessages.length) {
+        output += visibleMessages[i] + '\n';
+      } else {
+        output += '\n';
+      }
+    }
+
+    // Status bar
+    const statusIcon = status === 'thinking' ? chalk.yellow('⏳ thinking...') : chalk.green('● idle');
+    const tokenStr = `${fmtNum(totalTokens)} tokens`;
+    const costStr = `$${totalCost.toFixed(4)}`;
+    const agentCount = `${agents.length} agents`;
+    const statusLine = ` ${statusIcon}  │  ${tokenStr}  │  ${costStr}  │  ${agentCount}`;
+
+    output += chalk.bgGray.white(' '.repeat(cols)) + '\n';
+    output += chalk.bgGray.white(statusLine.padEnd(cols)) + '\n';
+
+    // Input area
+    output += chalk.gray('─'.repeat(cols)) + '\n';
+    output += chalk.green(' > ') + inputBuffer;
+
+    process.stdout.write(output);
+  }
+
+  function getVisibleMessages(maxLines, cols) {
+    const lines = [];
+    const maxWidth = cols - 4;
+
+    for (const msg of messages) {
+      if (msg.role === 'user') {
+        const wrapped = wrapText(msg.content, maxWidth);
+        for (const line of wrapped) {
+          lines.push(chalk.green(`  You: `) + line);
+        }
+      } else {
+        const wrapped = wrapText(msg.content, maxWidth);
+        const name = chalk.cyan(`  ${currentAgent.name}: `);
+        for (let i = 0; i < wrapped.length; i++) {
+          lines.push((i === 0 ? name : '        ') + wrapped[i]);
+        }
+      }
+      lines.push(''); // spacing
+    }
+
+    // Return last N lines that fit
+    return lines.slice(-maxLines);
+  }
+
+  function wrapText(text, maxWidth) {
+    const lines = [];
+    for (const paragraph of text.split('\n')) {
+      if (paragraph.length <= maxWidth) {
+        lines.push(paragraph);
+      } else {
+        let remaining = paragraph;
+        while (remaining.length > maxWidth) {
+          let breakAt = remaining.lastIndexOf(' ', maxWidth);
+          if (breakAt <= 0) breakAt = maxWidth;
+          lines.push(remaining.slice(0, breakAt));
+          remaining = remaining.slice(breakAt).trim();
+        }
+        if (remaining) lines.push(remaining);
+      }
+    }
+    return lines;
+  }
+
+  async function sendMessage(text) {
+    if (!text.trim()) return;
+
+    // Handle slash commands
+    if (text.startsWith('/')) {
+      await handleCommand(text.trim());
+      return;
+    }
+
+    messages.push({ role: 'user', content: text });
+    status = 'thinking';
+    render();
+
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/api/agents/${currentAgent.id}/chat`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ message: text, contactId: 'tui' }),
+      });
+      const data = await res.json();
+
+      if (data.reaction && !data.messages?.length) {
+        messages.push({ role: 'assistant', content: data.reaction });
+      } else {
+        for (const msg of data.messages || []) {
+          messages.push({ role: 'assistant', content: msg });
+        }
+      }
+
+      if (data.usage) {
+        totalTokens += (data.usage.inputTokens || 0) + (data.usage.outputTokens || 0);
+        totalCost += data.usage.cost || 0;
+      }
+    } catch (err) {
+      messages.push({ role: 'assistant', content: chalk.red(`Error: ${err.message}`) });
+    }
+
+    status = 'idle';
+    render();
+  }
+
+  async function handleCommand(cmd) {
+    const [command, ...args] = cmd.slice(1).split(' ');
+
+    switch (command) {
+      case 'help':
+        messages.push({ role: 'assistant', content: 
+          '📋 Commands:\n/help — this message\n/agents — list agents\n/agent <id> — switch agent\n/model <name> — switch model\n/status — show status\n/clear — clear chat\n/usage — show usage\n/exit — quit' });
+        break;
+
+      case 'agents':
+        const list = agents.map(a => `  ${a.id === currentAgent.id ? '→' : ' '} ${a.name} (${a.id})`).join('\n');
+        messages.push({ role: 'assistant', content: `🦑 Agents:\n${list}` });
+        break;
+
+      case 'agent':
+        if (args[0]) {
+          const found = agents.find(a => a.id === args[0] || a.name.toLowerCase() === args[0].toLowerCase());
+          if (found) {
+            currentAgent = found;
+            currentModel = found.model || config.ai?.defaultModel;
+            messages.length = 0;
+            messages.push({ role: 'assistant', content: `Switched to ${found.name} 🦑` });
+          } else {
+            messages.push({ role: 'assistant', content: `Agent "${args[0]}" not found` });
+          }
+        }
+        break;
+
+      case 'model':
+        if (args[0]) {
+          currentModel = args[0];
+          messages.push({ role: 'assistant', content: `Model → ${args[0]}` });
+        } else {
+          messages.push({ role: 'assistant', content: `Current model: ${currentModel}` });
+        }
+        break;
+
+      case 'status':
+        try {
+          const res = await fetch(`http://127.0.0.1:${port}/health`);
+          const data = await res.json();
+          messages.push({ role: 'assistant', content: 
+            `🦑 Status:\n  Agents: ${data.agents}\n  WhatsApp: ${data.whatsapp} connected\n  Uptime: ${Math.floor(data.uptime / 60)}m\n  Tokens: ${fmtNum(totalTokens)}\n  Cost: $${totalCost.toFixed(4)}` });
+        } catch {
+          messages.push({ role: 'assistant', content: 'Engine not responding' });
+        }
+        break;
+
+      case 'clear':
+        messages.length = 0;
+        break;
+
+      case 'usage':
+        messages.push({ role: 'assistant', content: 
+          `📊 This session:\n  Tokens: ${fmtNum(totalTokens)}\n  Cost: $${totalCost.toFixed(4)}\n  Messages: ${messages.filter(m => m.role === 'user').length}` });
+        break;
+
+      case 'exit':
+      case 'quit':
+        console.log(CLEAR_SCREEN + SHOW_CURSOR);
+        console.log(chalk.cyan('  👋 Bye!\n'));
+        process.exit(0);
+        break;
+
+      default:
+        messages.push({ role: 'assistant', content: `Unknown command: /${command}. Try /help` });
+    }
+    render();
+  }
+
+  // Initial render
+  render();
+
+  // Handle input
+  rl.on('line', async (line) => {
+    inputBuffer = '';
+    await sendMessage(line);
+  });
+
+  rl.on('close', () => {
+    console.log(CLEAR_SCREEN + SHOW_CURSOR);
+    console.log(chalk.cyan('  👋 Bye!\n'));
+    process.exit(0);
+  });
+
+  // Handle resize
+  process.stdout.on('resize', () => render());
+}
+
+function fmtNum(n) {
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return String(n);
+}

package/lib/cli/update-cmd.js

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+
+export async function update() {
+  console.log(chalk.cyan('🦑 Checking for updates...'));
+  try {
+    const current = execSync('npm view squidclaw version 2>/dev/null', { encoding: 'utf8' }).trim();
+    const { readFileSync } = await import('fs');
+    const { join, dirname } = await import('path');
+    const { fileURLToPath } = await import('url');
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
+    
+    if (current && current !== pkg.version) {
+      console.log(`  Current: ${pkg.version} → Latest: ${current}`);
+      console.log(chalk.cyan('  Updating...'));
+      execSync('npm i -g squidclaw@latest', { stdio: 'inherit' });
+      console.log(chalk.green('  ✅ Updated!'));
+    } else {
+      console.log(chalk.green(`  ✅ Already on latest (${pkg.version})`));
+    }
+  } catch {
+    console.log(chalk.yellow('  Could not check for updates. Try: npm i -g squidclaw@latest'));
+  }
+}

package/lib/cli/webhook-cmd.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function addWebhook(url) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/webhooks`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ url }),
+    });
+    const data = await res.json();
+    console.log(chalk.green(`✅ Webhook added (${data.id}): ${url}`));
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function listWebhooks() {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/webhooks`);
+    const webhooks = await res.json();
+    console.log(chalk.cyan(`\n  🔗 Webhooks (${webhooks.length})\n  ──────────`));
+    for (const wh of webhooks) {
+      console.log(`  ${wh.id}: ${wh.url}`);
+    }
+    if (webhooks.length === 0) console.log(chalk.gray('  No webhooks'));
+    console.log();
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function removeWebhook(id) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/webhooks/${id}`, { method: 'DELETE' });
+    console.log(chalk.green(`✅ Webhook ${id} removed`));
+  } catch { console.log(chalk.red('Engine not running')); }
+}

package/lib/core/agent-manager.js

@@ -0,0 +1,83 @@
+/**
+ * 🦑 Agent Manager
+ * Loads and manages all agent instances
+ */
+
+import { Agent } from './agent.js';
+import { logger } from './logger.js';
+
+export class AgentManager {
+  constructor(storage, aiGateway) {
+    this.storage = storage;
+    this.aiGateway = aiGateway;
+    this.agents = new Map(); // id → Agent instance
+    this.whatsappMap = new Map(); // whatsapp number → agent id
+  }
+
+  async loadAll() {
+    const agentRows = await this.storage.listAgents();
+    for (const row of agentRows) {
+      this._loadAgent(row);
+    }
+    logger.info('agent-manager', `Loaded ${this.agents.size} agents`);
+  }
+
+  _loadAgent(row) {
+    const agent = new Agent(row, this.storage, this.aiGateway);
+    this.agents.set(agent.id, agent);
+    if (row.whatsapp_number) {
+      this.whatsappMap.set(row.whatsapp_number, agent.id);
+    }
+    return agent;
+  }
+
+  get(id) {
+    return this.agents.get(id);
+  }
+
+  getByWhatsApp(number) {
+    // Clean the number for matching
+    const clean = number.replace(/[^0-9]/g, '');
+    for (const [num, agentId] of this.whatsappMap) {
+      if (num.replace(/[^0-9]/g, '') === clean) {
+        return this.agents.get(agentId);
+      }
+    }
+    // If only one agent exists, route to it (single-agent mode)
+    if (this.agents.size === 1) {
+      return this.agents.values().next().value;
+    }
+    return null;
+  }
+
+  getAll() {
+    return Array.from(this.agents.values());
+  }
+
+  async create(agentData) {
+    const created = await this.storage.createAgent(agentData);
+    return this._loadAgent({ ...agentData, id: created.id });
+  }
+
+  async update(id, updates) {
+    await this.storage.updateAgent(id, updates);
+    // Reload the agent
+    const row = await this.storage.getAgent(id);
+    if (row) {
+      const oldAgent = this.agents.get(id);
+      if (oldAgent?.whatsappNumber) {
+        this.whatsappMap.delete(oldAgent.whatsappNumber);
+      }
+      this._loadAgent(row);
+    }
+  }
+
+  async delete(id) {
+    const agent = this.agents.get(id);
+    if (agent?.whatsappNumber) {
+      this.whatsappMap.delete(agent.whatsappNumber);
+    }
+    this.agents.delete(id);
+    await this.storage.deleteAgent(id);
+  }
+}

package/lib/core/agent.js

@@ -0,0 +1,162 @@
+/**
+ * 🦑 Agent
+ * Single agent instance — soul, memory, chat processing
+ */
+
+import { logger } from './logger.js';
+import { PromptBuilder } from '../ai/prompt-builder.js';
+import { BehaviorEngine } from '../behavior/engine.js';
+
+export class Agent {
+  constructor(agentData, storage, aiGateway) {
+    this.id = agentData.id;
+    this.name = agentData.name;
+    this.soul = agentData.soul;
+    this.language = agentData.language || 'en';
+    this.tone = agentData.tone ?? 50;
+    this.model = agentData.model;
+    this.fallbackChain = agentData.fallback_chain || [];
+    this.behavior = agentData.behavior || {};
+    this.timezone = agentData.timezone || 'UTC';
+    this.status = agentData.status || 'active';
+    this.whatsappNumber = agentData.whatsapp_number;
+
+    this.storage = storage;
+    this.aiGateway = aiGateway;
+    this.promptBuilder = new PromptBuilder(storage);
+    this.behaviorEngine = new BehaviorEngine();
+
+    // Track active handoffs
+    this.activeHandoffs = new Set();
+
+    logger.info('agent', `Agent "${this.name}" (${this.id}) loaded`);
+  }
+
+  /**
+   * Process an incoming message and generate response
+   * Returns: { messages: string[], reaction: string|null, handoff: boolean }
+   */
+  async processMessage(contactId, message, metadata = {}) {
+    if (this.status !== 'active') {
+      return { messages: [], reaction: null, handoff: false };
+    }
+
+    // Check if this contact is in handoff mode
+    if (this.activeHandoffs.has(contactId)) {
+      logger.info('agent', `Message from ${contactId} — in handoff mode, skipping`);
+      return { messages: [], reaction: null, handoff: true };
+    }
+
+    // Save incoming message
+    await this.storage.saveMessage(this.id, contactId, 'user', message, metadata);
+
+    // Detect emotion and language
+    const emotion = this.behaviorEngine.detectEmotion(message);
+    const language = this.behaviorEngine.detectLanguage(message);
+
+    // Check if it's just a conversation ending
+    if (this.behaviorEngine.isConversationEnding(message)) {
+      const reaction = this.behaviorEngine.suggestReaction(message, emotion);
+      if (reaction) {
+        return { messages: [], reaction, handoff: false };
+      }
+    }
+
+    // Build system prompt
+    const systemPrompt = await this.promptBuilder.build(this, contactId, message);
+
+    // Get conversation history
+    const history = await this.storage.getConversation(this.id, contactId, 50);
+
+    // Build messages array for AI
+    const messages = [
+      { role: 'system', content: systemPrompt },
+      ...history.map(h => ({ role: h.role, content: h.content })),
+    ];
+
+    // If the last message in history is already the current message, don't add again
+    if (history.length === 0 || history[history.length - 1].content !== message) {
+      messages.push({ role: 'user', content: message });
+    }
+
+    // Add emotion context hint
+    if (emotion !== 'neutral') {
+      const emotionHints = {
+        angry: '[The person seems upset/angry. Be empathetic, acknowledge their frustration, keep responses short.]',
+        happy: '[The person seems happy/positive. Match their energy!]',
+        confused: '[The person seems confused. Simplify your explanation, use examples.]',
+        urgent: '[This seems urgent. Be direct and skip pleasantries.]',
+      };
+      messages.push({ role: 'user', content: emotionHints[emotion] });
+      // Remove the hint — it's just context for the AI
+      messages.pop();
+      // Instead, append to system prompt
+      messages[0].content += '\n\n' + emotionHints[emotion];
+    }
+
+    // Call AI
+    try {
+      const aiResponse = await this.aiGateway.chat(messages, {
+        model: this.model,
+        fallbackChain: this.fallbackChain,
+        temperature: this.behavior.temperature,
+      });
+
+      // Track usage
+      await this.storage.trackUsage(
+        this.id,
+        aiResponse.model,
+        aiResponse.inputTokens,
+        aiResponse.outputTokens,
+        aiResponse.costUsd
+      );
+
+      // Process response through behavior engine
+      const processed = this.behaviorEngine.process(aiResponse.content);
+
+      // Save memory updates
+      for (const mem of processed.memoryUpdates) {
+        await this.storage.saveMemory(this.id, mem.key, mem.value, 'fact');
+        logger.debug('agent', `Memory saved: ${mem.key} = ${mem.value}`);
+      }
+
+      // Save assistant response(s)
+      const fullResponse = processed.messages.join('\n');
+      if (fullResponse) {
+        await this.storage.saveMessage(this.id, contactId, 'assistant', fullResponse);
+      }
+
+      // Handle handoff
+      if (processed.handoff) {
+        this.activeHandoffs.add(contactId);
+        await this.storage.createHandoff(this.id, contactId, processed.handoff);
+        logger.info('agent', `Handoff triggered for ${contactId}: ${processed.handoff}`);
+      }
+
+      return {
+        messages: processed.messages,
+        reaction: processed.reaction,
+        handoff: !!processed.handoff,
+        usage: {
+          inputTokens: aiResponse.inputTokens,
+          outputTokens: aiResponse.outputTokens,
+          cost: aiResponse.costUsd,
+        },
+      };
+    } catch (err) {
+      logger.error('agent', `AI call failed for ${this.name}: ${err.message}`);
+      return {
+        messages: ['Sorry, I\'m having a technical issue right now. Please try again in a moment 🙏'],
+        reaction: null,
+        handoff: false,
+      };
+    }
+  }
+
+  /**
+   * Resolve a handoff — hand conversation back to agent
+   */
+  resolveHandoff(contactId) {
+    this.activeHandoffs.delete(contactId);
+  }
+}