squidclaw 0.1.0

package/lib/core/config.js

@@ -0,0 +1,172 @@
+/**
+ * 🦑 Squidclaw Config System
+ * Handles loading, saving, and validating configuration
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const SQUIDCLAW_HOME = process.env.SQUIDCLAW_HOME || join(homedir(), '.squidclaw');
+const CONFIG_FILE = join(SQUIDCLAW_HOME, 'config.json');
+
+const DEFAULT_CONFIG = {
+  engine: {
+    port: 9500,
+    bind: '127.0.0.1',
+    mode: 'standalone', // standalone | platform
+  },
+  ai: {
+    defaultProvider: null,
+    defaultModel: null,
+    fallbackChain: [],
+    providers: {
+      anthropic: { key: null, models: ['claude-opus-4', 'claude-sonnet-4', 'claude-haiku-3.5'] },
+      openai: { key: null, models: ['gpt-4o', 'gpt-4o-mini', 'o3', 'o4-mini'] },
+      google: { key: null, models: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.0-flash'] },
+      groq: { key: null, models: ['llama-4-scout', 'llama-4-maverick', 'llama-3.3-70b'] },
+      together: { key: null, models: ['llama-4-scout', 'llama-4-maverick'] },
+      cerebras: { key: null, models: ['llama-3.3-70b'] },
+      openrouter: { key: null, models: [] },
+      mistral: { key: null, models: ['mistral-large', 'mistral-medium', 'mistral-small'] },
+      ollama: { key: 'local', baseUrl: 'http://localhost:11434', models: [] },
+      lmstudio: { key: 'local', baseUrl: 'http://localhost:1234', models: [] },
+    },
+  },
+  channels: {
+    whatsapp: { enabled: false },
+    telegram: { enabled: false },
+  },
+  storage: {
+    type: 'sqlite', // sqlite | supabase
+    sqlite: { path: join(SQUIDCLAW_HOME, 'squidclaw.db') },
+    supabase: { url: null, key: null },
+  },
+  platform: {
+    enabled: false,
+    platformKey: null, // default API key for all agents
+    allowUserKeys: true,
+  },
+};
+
+// Model name → full API model ID mapping
+export const MODEL_MAP = {
+  // Anthropic
+  'claude-opus-4': 'claude-opus-4-20250514',
+  'claude-sonnet-4': 'claude-sonnet-4-20250514',
+  'claude-haiku-3.5': 'claude-3-5-haiku-20241022',
+  // OpenAI
+  'gpt-4o': 'gpt-4o',
+  'gpt-4o-mini': 'gpt-4o-mini',
+  'o3': 'o3',
+  'o4-mini': 'o4-mini',
+  // Google
+  'gemini-2.5-pro': 'gemini-2.5-pro-latest',
+  'gemini-2.5-flash': 'gemini-2.5-flash-preview-05-20',
+  'gemini-2.0-flash': 'gemini-2.0-flash',
+  // Groq
+  'groq/llama-4-scout': 'meta-llama/llama-4-scout-17b-16e-instruct',
+  'groq/llama-4-maverick': 'meta-llama/llama-4-maverick-17b-128e-instruct',
+  'groq/llama-3.3-70b': 'llama-3.3-70b-versatile',
+  // Together
+  'together/llama-4-scout': 'meta-llama/Llama-4-Scout-17B-16E-Instruct',
+  'together/llama-4-maverick': 'meta-llama/Llama-4-Maverick-17B-128E-Instruct',
+  // Cerebras
+  'cerebras/llama-3.3-70b': 'llama-3.3-70b',
+  // Mistral
+  'mistral-large': 'mistral-large-latest',
+  'mistral-medium': 'mistral-medium-latest',
+  'mistral-small': 'mistral-small-latest',
+};
+
+// Pricing per 1M tokens (input/output)
+export const MODEL_PRICING = {
+  'claude-opus-4': { input: 15, output: 75 },
+  'claude-sonnet-4': { input: 3, output: 15 },
+  'claude-haiku-3.5': { input: 0.8, output: 4 },
+  'gpt-4o': { input: 2.5, output: 10 },
+  'gpt-4o-mini': { input: 0.15, output: 0.6 },
+  'o3': { input: 10, output: 40 },
+  'o4-mini': { input: 1.1, output: 4.4 },
+  'gemini-2.5-pro': { input: 1.25, output: 10 },
+  'gemini-2.5-flash': { input: 0.15, output: 0.6 },
+  'gemini-2.0-flash': { input: 0.1, output: 0.4 },
+  'groq/llama-4-scout': { input: 0, output: 0 },
+  'groq/llama-4-maverick': { input: 0, output: 0 },
+  'groq/llama-3.3-70b': { input: 0, output: 0 },
+  'together/llama-4-scout': { input: 0, output: 0 },
+  'cerebras/llama-3.3-70b': { input: 0, output: 0 },
+};
+
+export function getHome() {
+  return SQUIDCLAW_HOME;
+}
+
+export function ensureHome() {
+  const dirs = [
+    SQUIDCLAW_HOME,
+    join(SQUIDCLAW_HOME, 'agents'),
+    join(SQUIDCLAW_HOME, 'channels'),
+    join(SQUIDCLAW_HOME, 'channels', 'whatsapp'),
+    join(SQUIDCLAW_HOME, 'knowledge'),
+    join(SQUIDCLAW_HOME, 'logs'),
+  ];
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function loadConfig() {
+  ensureHome();
+  if (!existsSync(CONFIG_FILE)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, 'utf8');
+    const loaded = JSON.parse(raw);
+    return deepMerge(DEFAULT_CONFIG, loaded);
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(config) {
+  ensureHome();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getConfig(key) {
+  const config = loadConfig();
+  if (!key) return config;
+  return key.split('.').reduce((obj, k) => obj?.[k], config);
+}
+
+export function setConfigValue(key, value) {
+  const config = loadConfig();
+  const keys = key.split('.');
+  let obj = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!obj[keys[i]]) obj[keys[i]] = {};
+    obj = obj[keys[i]];
+  }
+  // Try to parse JSON values
+  try {
+    obj[keys[keys.length - 1]] = JSON.parse(value);
+  } catch {
+    obj[keys[keys.length - 1]] = value;
+  }
+  saveConfig(config);
+  return config;
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}

package/lib/core/logger.js

@@ -0,0 +1,43 @@
+/**
+ * 🦑 Squidclaw Logger
+ */
+
+import { createWriteStream, mkdirSync } from 'fs';
+import { join } from 'path';
+import { getHome } from './config.js';
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3, trace: 4 };
+let currentLevel = LEVELS.info;
+let logStream = null;
+
+export function initLogger(level = 'info') {
+  currentLevel = LEVELS[level] ?? LEVELS.info;
+  const logDir = join(getHome(), 'logs');
+  mkdirSync(logDir, { recursive: true });
+  const logFile = join(logDir, 'squidclaw.log');
+  logStream = createWriteStream(logFile, { flags: 'a' });
+}
+
+function log(level, component, message, data) {
+  if (LEVELS[level] > currentLevel) return;
+  const entry = {
+    ts: new Date().toISOString(),
+    level,
+    component,
+    msg: message,
+    ...(data ? { data } : {}),
+  };
+  const line = JSON.stringify(entry);
+  if (logStream) logStream.write(line + '\n');
+  if (level === 'error') console.error(`[${component}] ${message}`);
+  else if (level === 'warn') console.warn(`[${component}] ${message}`);
+  else if (currentLevel >= LEVELS.debug) console.log(`[${component}] ${message}`);
+}
+
+export const logger = {
+  error: (component, msg, data) => log('error', component, msg, data),
+  warn: (component, msg, data) => log('warn', component, msg, data),
+  info: (component, msg, data) => log('info', component, msg, data),
+  debug: (component, msg, data) => log('debug', component, msg, data),
+  trace: (component, msg, data) => log('trace', component, msg, data),
+};

package/lib/engine.js

@@ -0,0 +1,117 @@
+/**
+ * 🦑 Squidclaw Engine
+ * Main entry point — starts all subsystems
+ */
+
+import { loadConfig, getHome, ensureHome } from './core/config.js';
+import { initLogger, logger } from './core/logger.js';
+import { AgentManager } from './core/agent-manager.js';
+import { AIGateway } from './ai/gateway.js';
+import { SQLiteStorage } from './storage/sqlite.js';
+import { WhatsAppManager } from './channels/whatsapp/manager.js';
+import { ChannelHub } from './channels/hub.js';
+import { HeartbeatSystem } from './features/heartbeat.js';
+import { createAPIServer } from './api/server.js';
+import { addMediaSupport } from './channels/hub-media.js';
+
+export class SquidclawEngine {
+  constructor(options = {}) {
+    this.config = loadConfig();
+    this.home = getHome();
+    this.port = options.port || this.config.engine?.port || 9500;
+    this.storage = null;
+    this.aiGateway = null;
+    this.agentManager = null;
+    this.whatsappManager = null;
+    this.channelHub = null;
+    this.heartbeat = null;
+    this.server = null;
+  }
+
+  async start() {
+    ensureHome();
+    initLogger(this.config.engine?.logLevel || 'info');
+
+    console.log(`
+  🦑 Squidclaw Engine v0.1.0
+  ──────────────────────────`);
+
+    // 1. Storage
+    const dbPath = this.config.storage?.sqlite?.path || `${this.home}/squidclaw.db`;
+    this.storage = new SQLiteStorage(dbPath);
+    console.log(`  💾 Storage: SQLite (${dbPath})`);
+
+    // 2. AI Gateway
+    this.aiGateway = new AIGateway(this.config);
+    const providers = Object.entries(this.config.ai?.providers || {})
+      .filter(([_, v]) => v.key)
+      .map(([k]) => k);
+    console.log(`  🧠 AI: ${providers.join(', ') || 'none configured'}`);
+    if (this.config.ai?.defaultModel) {
+      console.log(`  🎯 Default model: ${this.config.ai.defaultModel}`);
+    }
+
+    // 3. Agent Manager
+    this.agentManager = new AgentManager(this.storage, this.aiGateway);
+    await this.agentManager.loadAll();
+    const agents = this.agentManager.getAll();
+    console.log(`  👥 Agents: ${agents.length} loaded`);
+
+    // 4. WhatsApp Manager
+    this.whatsappManager = new WhatsAppManager(this.config, this.agentManager, this.home);
+
+    // Start WhatsApp sessions for all agents that have them configured
+    for (const agent of agents) {
+      if (agent.status === 'active' && agent.whatsappNumber) {
+        try {
+          await this.whatsappManager.startSession(agent.id);
+        } catch (err) {
+          logger.warn('engine', `Failed to start WhatsApp for "${agent.name}": ${err.message}`);
+        }
+      }
+    }
+    const waStatuses = this.whatsappManager.getStatuses();
+    const connected = Object.values(waStatuses).filter(s => s.connected).length;
+    console.log(`  📱 WhatsApp: ${connected}/${agents.length} connected`);
+
+    // 5. Channel Hub
+    this.channelHub = new ChannelHub(this.agentManager, this.whatsappManager, this.storage);
+    addMediaSupport(this.channelHub, this.config, this.home);
+
+    // 6. Heartbeat
+    this.heartbeat = new HeartbeatSystem(this.agentManager, this.whatsappManager, this.storage);
+    this.heartbeat.start();
+    console.log(`  💓 Heartbeat: active`);
+
+    // 7. API Server
+    const app = createAPIServer(this);
+    this.server = app.listen(this.port, this.config.engine?.bind || '127.0.0.1', () => {
+      console.log(`  🌐 API: http://${this.config.engine?.bind || '127.0.0.1'}:${this.port}`);
+      console.log(`  ──────────────────────────`);
+      console.log(`  ✅ Engine running!\n`);
+    });
+
+    // Graceful shutdown
+    process.on('SIGINT', () => this.stop());
+    process.on('SIGTERM', () => this.stop());
+  }
+
+  async stop() {
+    console.log('\n  🦑 Shutting down...');
+    this.heartbeat?.stop();
+    await this.whatsappManager?.stopAll();
+    this.storage?.close();
+    this.server?.close();
+    console.log('  👋 Bye!\n');
+    process.exit(0);
+  }
+}
+
+// Auto-start if run directly
+if (process.argv[1]?.endsWith('engine.js')) {
+  const engine = new SquidclawEngine();
+  engine.start().catch(err => {
+    console.error('Fatal:', err.message);
+    process.exit(1);
+  });
+}

package/lib/features/heartbeat.js

@@ -0,0 +1,71 @@
+/**
+ * 🦑 Heartbeat System
+ * Periodic agent tasks — proactive messages, follow-ups, scheduled sends
+ */
+
+import { Cron } from 'croner';
+import { logger } from '../core/logger.js';
+
+export class HeartbeatSystem {
+  constructor(agentManager, whatsappManager, storage) {
+    this.agentManager = agentManager;
+    this.whatsappManager = whatsappManager;
+    this.storage = storage;
+    this.jobs = [];
+  }
+
+  start() {
+    // Check scheduled messages every minute
+    this.jobs.push(new Cron('* * * * *', async () => {
+      await this._processScheduledMessages();
+    }));
+
+    // Health check all agents every 5 minutes
+    this.jobs.push(new Cron('*/5 * * * *', async () => {
+      await this._healthCheck();
+    }));
+
+    logger.info('heartbeat', 'Heartbeat system started');
+  }
+
+  stop() {
+    for (const job of this.jobs) {
+      job.stop();
+    }
+    this.jobs = [];
+  }
+
+  async _processScheduledMessages() {
+    try {
+      const due = await this.storage.getDueMessages();
+      for (const msg of due) {
+        try {
+          await this.whatsappManager.sendMessage(msg.agent_id, msg.contact_id, msg.message);
+          await this.storage.markMessageSent(msg.id);
+          logger.info('heartbeat', `Sent scheduled message ${msg.id} to ${msg.contact_id}`);
+        } catch (err) {
+          logger.error('heartbeat', `Failed to send scheduled message ${msg.id}: ${err.message}`);
+        }
+      }
+    } catch (err) {
+      logger.error('heartbeat', `Scheduled message check failed: ${err.message}`);
+    }
+  }
+
+  async _healthCheck() {
+    const statuses = this.whatsappManager.getStatuses();
+    const agents = this.agentManager.getAll();
+
+    for (const agent of agents) {
+      const waStatus = statuses[agent.id];
+      if (agent.status === 'active' && agent.whatsappNumber && (!waStatus || !waStatus.connected)) {
+        logger.warn('heartbeat', `Agent "${agent.name}" WhatsApp disconnected — attempting reconnect`);
+        try {
+          await this.whatsappManager.startSession(agent.id);
+        } catch (err) {
+          logger.error('heartbeat', `Reconnect failed for "${agent.name}": ${err.message}`);
+        }
+      }
+    }
+  }
+}

package/lib/storage/interface.js

@@ -0,0 +1,56 @@
+/**
+ * 🦑 Storage Interface
+ * Abstract interface for all storage operations
+ */
+
+export class StorageInterface {
+  // ── Agents ──
+  async createAgent(agent) { throw new Error('Not implemented'); }
+  async getAgent(id) { throw new Error('Not implemented'); }
+  async listAgents() { throw new Error('Not implemented'); }
+  async updateAgent(id, updates) { throw new Error('Not implemented'); }
+  async deleteAgent(id) { throw new Error('Not implemented'); }
+
+  // ── Conversations ──
+  async saveMessage(agentId, contactId, role, content, metadata) { throw new Error('Not implemented'); }
+  async getConversation(agentId, contactId, limit) { throw new Error('Not implemented'); }
+  async searchConversations(query, agentId) { throw new Error('Not implemented'); }
+
+  // ── Memory ──
+  async saveMemory(agentId, key, value, type) { throw new Error('Not implemented'); }
+  async getMemories(agentId, type) { throw new Error('Not implemented'); }
+  async deleteMemory(agentId, key) { throw new Error('Not implemented'); }
+  async clearMemories(agentId) { throw new Error('Not implemented'); }
+
+  // ── Knowledge / RAG ──
+  async saveDocument(agentId, doc) { throw new Error('Not implemented'); }
+  async saveChunks(docId, chunks) { throw new Error('Not implemented'); }
+  async searchKnowledge(agentId, embedding, limit) { throw new Error('Not implemented'); }
+  async listDocuments(agentId) { throw new Error('Not implemented'); }
+  async deleteDocument(docId) { throw new Error('Not implemented'); }
+
+  // ── Usage ──
+  async trackUsage(agentId, model, inputTokens, outputTokens, costUsd) { throw new Error('Not implemented'); }
+  async getUsage(agentId, period) { throw new Error('Not implemented'); }
+  async getUsageAll(period) { throw new Error('Not implemented'); }
+
+  // ── Handoffs ──
+  async createHandoff(agentId, contactId, reason) { throw new Error('Not implemented'); }
+  async getActiveHandoffs() { throw new Error('Not implemented'); }
+  async resolveHandoff(id) { throw new Error('Not implemented'); }
+
+  // ── Webhooks ──
+  async addWebhook(url, events) { throw new Error('Not implemented'); }
+  async getWebhooks() { throw new Error('Not implemented'); }
+  async removeWebhook(id) { throw new Error('Not implemented'); }
+
+  // ── Contacts ──
+  async saveContact(agentId, contactId, name, metadata) { throw new Error('Not implemented'); }
+  async getContact(agentId, contactId) { throw new Error('Not implemented'); }
+  async listContacts(agentId) { throw new Error('Not implemented'); }
+
+  // ── Scheduled Messages ──
+  async scheduleMessage(agentId, contactId, message, sendAt) { throw new Error('Not implemented'); }
+  async getDueMessages() { throw new Error('Not implemented'); }
+  async markMessageSent(id) { throw new Error('Not implemented'); }
+}