squidclaw 0.1.0

package/lib/storage/sqlite.js

@@ -0,0 +1,409 @@
+/**
+ * 🦑 SQLite Storage Driver
+ * Zero-config local storage with vector search support
+ */
+
+import Database from 'better-sqlite3';
+import { StorageInterface } from './interface.js';
+import { logger } from '../core/logger.js';
+import crypto from 'crypto';
+
+export class SQLiteStorage extends StorageInterface {
+  constructor(dbPath) {
+    super();
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('foreign_keys = ON');
+    this._migrate();
+  }
+
+  _migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        soul TEXT,
+        language TEXT DEFAULT 'en',
+        tone INTEGER DEFAULT 50,
+        model TEXT,
+        fallback_chain TEXT DEFAULT '[]',
+        behavior TEXT DEFAULT '{}',
+        business_hours TEXT,
+        timezone TEXT DEFAULT 'UTC',
+        whatsapp_number TEXT,
+        telegram_bot_token TEXT,
+        status TEXT DEFAULT 'active',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS conversations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        media_type TEXT,
+        media_url TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_conv_agent_contact ON conversations(agent_id, contact_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        type TEXT DEFAULT 'fact',
+        importance INTEGER DEFAULT 5,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE,
+        UNIQUE(agent_id, key)
+      );
+
+      CREATE TABLE IF NOT EXISTS documents (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        filename TEXT NOT NULL,
+        file_type TEXT,
+        file_size INTEGER,
+        chunk_count INTEGER DEFAULT 0,
+        status TEXT DEFAULT 'processing',
+        created_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        doc_id TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        embedding BLOB,
+        chunk_index INTEGER,
+        FOREIGN KEY (doc_id) REFERENCES documents(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        model TEXT,
+        input_tokens INTEGER DEFAULT 0,
+        output_tokens INTEGER DEFAULT 0,
+        cost_usd REAL DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_usage_agent_date ON usage(agent_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS handoffs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        reason TEXT,
+        status TEXT DEFAULT 'pending',
+        created_at TEXT DEFAULT (datetime('now')),
+        resolved_at TEXT,
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS webhooks (
+        id TEXT PRIMARY KEY,
+        url TEXT NOT NULL,
+        events TEXT DEFAULT '["*"]',
+        active INTEGER DEFAULT 1,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS contacts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        name TEXT,
+        metadata TEXT DEFAULT '{}',
+        first_seen TEXT DEFAULT (datetime('now')),
+        last_seen TEXT DEFAULT (datetime('now')),
+        message_count INTEGER DEFAULT 0,
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE,
+        UNIQUE(agent_id, contact_id)
+      );
+
+      CREATE TABLE IF NOT EXISTS scheduled_messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id TEXT NOT NULL,
+        contact_id TEXT NOT NULL,
+        message TEXT NOT NULL,
+        send_at TEXT NOT NULL,
+        sent INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+      );
+    `);
+    logger.info('storage', 'SQLite database initialized');
+  }
+
+  // ── Agents ──
+  async createAgent(agent) {
+    const id = agent.id || crypto.randomUUID();
+    this.db.prepare(`
+      INSERT INTO agents (id, name, soul, language, tone, model, behavior, business_hours, timezone)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, agent.name, agent.soul || '', agent.language || 'en', agent.tone ?? 50,
+      agent.model || null, JSON.stringify(agent.behavior || {}),
+      agent.businessHours || null, agent.timezone || 'UTC');
+    return { id, ...agent };
+  }
+
+  async getAgent(id) {
+    const row = this.db.prepare('SELECT * FROM agents WHERE id = ?').get(id);
+    if (!row) return null;
+    row.behavior = JSON.parse(row.behavior || '{}');
+    row.fallback_chain = JSON.parse(row.fallback_chain || '[]');
+    return row;
+  }
+
+  async listAgents() {
+    const rows = this.db.prepare('SELECT * FROM agents ORDER BY created_at DESC').all();
+    return rows.map(r => ({ ...r, behavior: JSON.parse(r.behavior || '{}'), fallback_chain: JSON.parse(r.fallback_chain || '[]') }));
+  }
+
+  async updateAgent(id, updates) {
+    const sets = [];
+    const vals = [];
+    for (const [k, v] of Object.entries(updates)) {
+      const col = k.replace(/([A-Z])/g, '_$1').toLowerCase();
+      sets.push(`${col} = ?`);
+      vals.push(typeof v === 'object' ? JSON.stringify(v) : v);
+    }
+    sets.push("updated_at = datetime('now')");
+    vals.push(id);
+    this.db.prepare(`UPDATE agents SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+  }
+
+  async deleteAgent(id) {
+    this.db.prepare('DELETE FROM agents WHERE id = ?').run(id);
+  }
+
+  // ── Conversations ──
+  async saveMessage(agentId, contactId, role, content, metadata = {}) {
+    this.db.prepare(`
+      INSERT INTO conversations (agent_id, contact_id, role, content, media_type, media_url, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(agentId, contactId, role, content, metadata.mediaType || null,
+      metadata.mediaUrl || null, JSON.stringify(metadata));
+
+    // Update contact
+    this.db.prepare(`
+      INSERT INTO contacts (agent_id, contact_id, name, message_count, last_seen)
+      VALUES (?, ?, ?, 1, datetime('now'))
+      ON CONFLICT(agent_id, contact_id) DO UPDATE SET
+        message_count = message_count + 1,
+        last_seen = datetime('now'),
+        name = COALESCE(excluded.name, contacts.name)
+    `).run(agentId, contactId, metadata.pushName || null);
+  }
+
+  async getConversation(agentId, contactId, limit = 50) {
+    return this.db.prepare(`
+      SELECT role, content, media_type, created_at FROM conversations
+      WHERE agent_id = ? AND contact_id = ?
+      ORDER BY created_at DESC LIMIT ?
+    `).all(agentId, contactId, limit).reverse();
+  }
+
+  async searchConversations(query, agentId) {
+    const sql = agentId
+      ? `SELECT * FROM conversations WHERE agent_id = ? AND content LIKE ? ORDER BY created_at DESC LIMIT 50`
+      : `SELECT * FROM conversations WHERE content LIKE ? ORDER BY created_at DESC LIMIT 50`;
+    const params = agentId ? [agentId, `%${query}%`] : [`%${query}%`];
+    return this.db.prepare(sql).all(...params);
+  }
+
+  // ── Memory ──
+  async saveMemory(agentId, key, value, type = 'fact') {
+    this.db.prepare(`
+      INSERT INTO memories (agent_id, key, value, type)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(agent_id, key) DO UPDATE SET value = ?, updated_at = datetime('now')
+    `).run(agentId, key, value, type, value);
+  }
+
+  async getMemories(agentId, type) {
+    const sql = type
+      ? 'SELECT * FROM memories WHERE agent_id = ? AND type = ? ORDER BY importance DESC, updated_at DESC'
+      : 'SELECT * FROM memories WHERE agent_id = ? ORDER BY importance DESC, updated_at DESC';
+    return type ? this.db.prepare(sql).all(agentId, type) : this.db.prepare(sql).all(agentId);
+  }
+
+  async deleteMemory(agentId, key) {
+    this.db.prepare('DELETE FROM memories WHERE agent_id = ? AND key = ?').run(agentId, key);
+  }
+
+  async clearMemories(agentId) {
+    this.db.prepare('DELETE FROM memories WHERE agent_id = ?').run(agentId);
+  }
+
+  // ── Knowledge ──
+  async saveDocument(agentId, doc) {
+    const id = doc.id || crypto.randomUUID();
+    this.db.prepare(`
+      INSERT INTO documents (id, agent_id, filename, file_type, file_size)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(id, agentId, doc.filename, doc.fileType, doc.fileSize || 0);
+    return id;
+  }
+
+  async saveChunks(docId, agentId, chunks) {
+    const insert = this.db.prepare(`
+      INSERT INTO chunks (doc_id, agent_id, content, embedding, chunk_index)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const tx = this.db.transaction((items) => {
+      for (let i = 0; i < items.length; i++) {
+        insert.run(docId, agentId, items[i].content, items[i].embedding || null, i);
+      }
+    });
+    tx(chunks);
+    this.db.prepare('UPDATE documents SET chunk_count = ?, status = ? WHERE id = ?')
+      .run(chunks.length, 'processed', docId);
+  }
+
+  async searchKnowledge(agentId, queryEmbedding, limit = 5) {
+    // Simple text search fallback when no embeddings
+    // TODO: implement cosine similarity with sqlite-vec
+    return this.db.prepare(`
+      SELECT content FROM chunks WHERE agent_id = ? LIMIT ?
+    `).all(agentId, limit);
+  }
+
+  async listDocuments(agentId) {
+    return this.db.prepare('SELECT * FROM documents WHERE agent_id = ? ORDER BY created_at DESC').all(agentId);
+  }
+
+  async deleteDocument(docId) {
+    this.db.prepare('DELETE FROM documents WHERE id = ?').run(docId);
+  }
+
+  // ── Usage ──
+  async trackUsage(agentId, model, inputTokens, outputTokens, costUsd) {
+    this.db.prepare(`
+      INSERT INTO usage (agent_id, model, input_tokens, output_tokens, cost_usd)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(agentId, model, inputTokens, outputTokens, costUsd);
+  }
+
+  async getUsage(agentId, period = '30d') {
+    const since = this._periodToDate(period);
+    return this.db.prepare(`
+      SELECT 
+        COUNT(*) as messages,
+        SUM(input_tokens) as input_tokens,
+        SUM(output_tokens) as output_tokens,
+        SUM(cost_usd) as cost_usd
+      FROM usage WHERE agent_id = ? AND created_at >= ?
+    `).get(agentId, since);
+  }
+
+  async getUsageAll(period = '30d') {
+    const since = this._periodToDate(period);
+    return this.db.prepare(`
+      SELECT 
+        agent_id,
+        COUNT(*) as messages,
+        SUM(input_tokens) as input_tokens,
+        SUM(output_tokens) as output_tokens,
+        SUM(cost_usd) as cost_usd
+      FROM usage WHERE created_at >= ?
+      GROUP BY agent_id
+    `).all(since);
+  }
+
+  // ── Handoffs ──
+  async createHandoff(agentId, contactId, reason) {
+    this.db.prepare(`
+      INSERT INTO handoffs (agent_id, contact_id, reason) VALUES (?, ?, ?)
+    `).run(agentId, contactId, reason);
+  }
+
+  async getActiveHandoffs() {
+    return this.db.prepare("SELECT * FROM handoffs WHERE status = 'pending' ORDER BY created_at DESC").all();
+  }
+
+  async resolveHandoff(id) {
+    this.db.prepare("UPDATE handoffs SET status = 'resolved', resolved_at = datetime('now') WHERE id = ?").run(id);
+  }
+
+  // ── Webhooks ──
+  async addWebhook(url, events = ['*']) {
+    const id = crypto.randomUUID().slice(0, 8);
+    this.db.prepare('INSERT INTO webhooks (id, url, events) VALUES (?, ?, ?)').run(id, url, JSON.stringify(events));
+    return id;
+  }
+
+  async getWebhooks() {
+    return this.db.prepare('SELECT * FROM webhooks WHERE active = 1').all()
+      .map(w => ({ ...w, events: JSON.parse(w.events) }));
+  }
+
+  async removeWebhook(id) {
+    this.db.prepare('DELETE FROM webhooks WHERE id = ?').run(id);
+  }
+
+  // ── Contacts ──
+  async saveContact(agentId, contactId, name, metadata = {}) {
+    this.db.prepare(`
+      INSERT INTO contacts (agent_id, contact_id, name, metadata)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(agent_id, contact_id) DO UPDATE SET
+        name = COALESCE(?, contacts.name),
+        metadata = ?,
+        last_seen = datetime('now')
+    `).run(agentId, contactId, name, JSON.stringify(metadata), name, JSON.stringify(metadata));
+  }
+
+  async getContact(agentId, contactId) {
+    return this.db.prepare('SELECT * FROM contacts WHERE agent_id = ? AND contact_id = ?').get(agentId, contactId);
+  }
+
+  async listContacts(agentId) {
+    return this.db.prepare('SELECT * FROM contacts WHERE agent_id = ? ORDER BY last_seen DESC').all(agentId);
+  }
+
+  // ── Scheduled Messages ──
+  async scheduleMessage(agentId, contactId, message, sendAt) {
+    this.db.prepare(`
+      INSERT INTO scheduled_messages (agent_id, contact_id, message, send_at)
+      VALUES (?, ?, ?, ?)
+    `).run(agentId, contactId, message, sendAt);
+  }
+
+  async getDueMessages() {
+    return this.db.prepare(`
+      SELECT * FROM scheduled_messages WHERE sent = 0 AND send_at <= datetime('now')
+    `).all();
+  }
+
+  async markMessageSent(id) {
+    this.db.prepare('UPDATE scheduled_messages SET sent = 1 WHERE id = ?').run(id);
+  }
+
+  // ── Helpers ──
+  _periodToDate(period) {
+    const now = new Date();
+    const match = period.match(/^(\d+)(d|w|m|y)$/);
+    if (!match) return new Date(0).toISOString();
+    const [, num, unit] = match;
+    const n = parseInt(num);
+    if (unit === 'd') now.setDate(now.getDate() - n);
+    else if (unit === 'w') now.setDate(now.getDate() - n * 7);
+    else if (unit === 'm') now.setMonth(now.getMonth() - n);
+    else if (unit === 'y') now.setFullYear(now.getFullYear() - n);
+    return now.toISOString();
+  }
+
+  close() {
+    this.db.close();
+  }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "squidclaw",
+  "version": "0.1.0",
+  "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
+  "main": "lib/engine.js",
+  "bin": {
+    "squidclaw": "./bin/squidclaw.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node lib/engine.js",
+    "test": "vitest",
+    "dev": "node --watch lib/engine.js"
+  },
+  "keywords": ["ai", "agent", "whatsapp", "chatbot", "claude", "openai", "squidclaw"],
+  "author": "Squidclaw",
+  "license": "MIT",
+  "homepage": "https://squidclaw.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/squidclaw/squidclaw"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "@hapi/boom": "^10.0.1",
+    "@clack/prompts": "^1.0.1",
+    "@mozilla/readability": "^0.6.0",
+    "better-sqlite3": "^11.0.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "croner": "^10.0.1",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "file-type": "^21.3.0",
+    "linkedom": "^0.18.12",
+    "node-edge-tts": "^1.2.10",
+    "pdfjs-dist": "^5.4.624",
+    "pino": "^10.3.1",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.34.5",
+    "undici": "^7.22.0",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  }
+}

package/templates/BEHAVIOR.md

@@ -0,0 +1,42 @@
+{
+  "splitMessages": true,
+  "maxChunkLength": 200,
+  "maxChunks": 4,
+  "delayBetweenChunks": "0.5-1.0",
+  "reactBeforeReply": true,
+  "reactOnlyEndings": true,
+  "favoriteEmojis": ["😍", "🔥", "❤️", "👍", "😂", "🙏"],
+  "autoDetectLanguage": true,
+  "defaultLanguage": "en",
+  "avoidPhrases": [
+    "Is there anything else I can help with?",
+    "I'd be happy to help!",
+    "Great question!",
+    "As an AI"
+  ],
+  "emotionResponse": {
+    "angry": "empathize_first, short_sentences, offer_escalation",
+    "happy": "match_energy, use_emojis",
+    "confused": "simplify, use_examples",
+    "urgent": "skip_pleasantries, be_direct"
+  },
+  "businessHours": null,
+  "timezone": "UTC",
+  "afterHoursMode": "24/7",
+  "voice": {
+    "enabled": false,
+    "provider": "edge-tts",
+    "name": "en-US-AriaNeural"
+  },
+  "handoff": {
+    "enabled": false,
+    "triggerPhrases": ["talk to a human", "speak to manager"],
+    "notify": []
+  },
+  "heartbeat": "30m",
+  "followUp": {
+    "enabled": false,
+    "delay": "24h",
+    "message": "Hey! Just checking in — did you need anything else? 😊"
+  }
+}

package/templates/IDENTITY.md

@@ -0,0 +1,7 @@
+# {agent_name}
+
+- **Name:** {agent_name}
+- **Language:** {language}
+- **Tone:** {tone_description}
+- **Emoji:** 🦑
+- **Created:** {date}

package/templates/RULES.md

@@ -0,0 +1,9 @@
+# Rules (non-negotiable)
+
+1. Be helpful, be human, be honest
+2. Keep messages short — this is WhatsApp, not email
+3. If unsure, say so instead of making things up
+4. Never share customer data with other customers
+5. Match the language the person writes in
+6. One emoji per message max — don't overdo it
+7. If someone is angry, empathize first, solve second

package/templates/SOUL.md

@@ -0,0 +1,19 @@
+# {agent_name}
+
+## Who I Am
+I'm {agent_name}. {agent_purpose}
+
+## How I Speak
+- Language: {language}
+- Tone: {tone_description}
+- Platform: WhatsApp — short messages, natural, human-like
+- I use emojis naturally but don't overdo it
+
+## What I Do
+{agent_purpose}
+
+## What I Never Do
+- Say "As an AI" or "I'd be happy to help" or "Great question!"
+- Send walls of text — I keep it short and conversational
+- Make things up when I don't know — I say "let me check" instead
+- Over-apologize — one "sorry" is enough