squidclaw 0.1.0

package/lib/cli/key-cmd.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../core/config.js';
+
+export async function setKey(provider, apiKey) {
+  const config = loadConfig();
+  if (!config.ai.providers[provider]) {
+    console.log(chalk.red(`Unknown provider: ${provider}`));
+    console.log(`Available: anthropic, openai, google, groq, together, cerebras, openrouter, mistral, ollama, lmstudio`);
+    return;
+  }
+  config.ai.providers[provider].key = apiKey;
+  if (!config.ai.defaultProvider) config.ai.defaultProvider = provider;
+  saveConfig(config);
+  console.log(chalk.green(`✅ ${provider} key saved`));
+}
+
+export async function testKey(opts) {
+  const config = loadConfig();
+  const provider = opts.provider || config.ai?.defaultProvider;
+  if (!provider) return console.log(chalk.red('No provider configured'));
+  
+  const key = config.ai.providers[provider]?.key;
+  if (!key) return console.log(chalk.red(`No key set for ${provider}`));
+
+  console.log(`Testing ${provider}...`);
+  try {
+    // Quick test with a simple request
+    const { AIGateway } = await import('../ai/gateway.js');
+    const gw = new AIGateway(config);
+    const result = await gw.chat([
+      { role: 'system', content: 'Reply with just: ok' },
+      { role: 'user', content: 'test' },
+    ], { model: config.ai.defaultModel });
+    console.log(chalk.green(`✅ ${provider} is working! (${result.model})`));
+  } catch (err) {
+    console.log(chalk.red(`❌ Failed: ${err.message}`));
+  }
+}
+
+export async function showKeys() {
+  const config = loadConfig();
+  console.log(chalk.cyan('\n  🔑 API Keys\n  ───────────'));
+  for (const [name, conf] of Object.entries(config.ai.providers)) {
+    if (conf.key && conf.key !== 'local') {
+      const masked = conf.key.slice(0, 10) + '...' + conf.key.slice(-4);
+      const isDefault = name === config.ai.defaultProvider ? chalk.green(' ← default') : '';
+      console.log(`  ${name}: ${masked}${isDefault}`);
+    } else if (conf.key === 'local') {
+      console.log(`  ${chalk.gray(name)}: local`);
+    }
+  }
+  console.log();
+}
+
+export async function removeKey(provider) {
+  const config = loadConfig();
+  if (config.ai.providers[provider]) {
+    config.ai.providers[provider].key = null;
+    saveConfig(config);
+    console.log(chalk.green(`✅ ${provider} key removed`));
+  }
+}

package/lib/cli/knowledge-cmd.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+import { readFileSync, statSync } from 'fs';
+import { basename, extname } from 'path';
+
+export async function uploadKnowledge(file, opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const agentId = opts.agent;
+  if (!agentId) return console.log(chalk.red('Specify agent: --agent <id>'));
+
+  try {
+    const content = readFileSync(file, 'utf8');
+    const stat = statSync(file);
+    const filename = basename(file);
+    const fileType = extname(file).slice(1);
+
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/knowledge`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ filename, fileType, content, fileSize: stat.size }),
+    });
+
+    if (res.ok) {
+      console.log(chalk.green(`✅ "${filename}" uploaded to ${agentId}'s knowledge base`));
+    } else {
+      const err = await res.json();
+      console.log(chalk.red(`Failed: ${err.error}`));
+    }
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}
+
+export async function listKnowledge(opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const agentId = opts.agent;
+  if (!agentId) return console.log(chalk.red('Specify agent: --agent <id>'));
+
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/knowledge`);
+    const docs = await res.json();
+    console.log(chalk.cyan(`\n  📚 Knowledge Base (${docs.length} docs)\n  ───────────────`));
+    for (const doc of docs) {
+      console.log(`  ${doc.filename} (${doc.file_type}) — ${doc.chunk_count} chunks — ${doc.status}`);
+    }
+    console.log();
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function deleteKnowledge(docId) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/knowledge/${docId}`, { method: 'DELETE' });
+    console.log(chalk.green('✅ Document deleted'));
+  } catch { console.log(chalk.red('Engine not running')); }
+}

package/lib/cli/memory-cmd.js

@@ -0,0 +1,50 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function showMemory(agentId) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/memory`);
+    const memories = await res.json();
+    console.log(chalk.cyan(`\n  🧠 Memory for ${agentId}\n  ───────────────`));
+    if (memories.length === 0) {
+      console.log(chalk.gray('  No memories yet'));
+    }
+    for (const m of memories) {
+      console.log(`  ${chalk.yellow(m.key)}: ${m.value}`);
+    }
+    console.log();
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function clearMemory(agentId, opts) {
+  if (!opts.confirm) {
+    const { default: p } = await import('@clack/prompts');
+    // Simple confirmation
+    console.log(chalk.yellow(`This will clear all memories for agent ${agentId}`));
+  }
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/memory`, { method: 'DELETE' });
+    console.log(chalk.green('✅ Memory cleared'));
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function exportMemory(agentId, opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents/${agentId}/memory`);
+    const memories = await res.json();
+    const output = JSON.stringify(memories, null, 2);
+    if (opts.output) {
+      const { writeFileSync } = await import('fs');
+      writeFileSync(opts.output, output);
+      console.log(chalk.green(`✅ Exported to ${opts.output}`));
+    } else {
+      console.log(output);
+    }
+  } catch { console.log(chalk.red('Engine not running')); }
+}

package/lib/cli/platform-cmd.js

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../core/config.js';
+
+export async function initPlatform(opts) {
+  if (!opts.supabaseUrl || !opts.supabaseKey) {
+    console.log(chalk.red('Required: --supabase-url <url> --supabase-key <key>'));
+    return;
+  }
+  const config = loadConfig();
+  config.engine.mode = 'platform';
+  config.platform.enabled = true;
+  config.storage.type = 'supabase';
+  config.storage.supabase.url = opts.supabaseUrl;
+  config.storage.supabase.key = opts.supabaseKey;
+  saveConfig(config);
+  console.log(chalk.green('✅ Platform mode enabled with Supabase'));
+}
+
+export async function platformAgents() {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/agents`);
+    const agents = await res.json();
+    console.log(chalk.cyan(`\n  🏢 Platform Agents (${agents.length})\n  ──────────────`));
+    for (const a of agents) {
+      console.log(`  ${a.name} (${a.id}) — ${a.model} — WA: ${a.whatsappConnected ? '✅' : '❌'}`);
+    }
+    console.log();
+  } catch { console.log(chalk.red('Engine not running')); }
+}
+
+export async function platformUsage() {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/usage`);
+    const data = await res.json();
+    console.log(chalk.cyan('\n  📊 Platform Usage\n  ─────────────'));
+    let total = { tokens: 0, cost: 0, msgs: 0 };
+    for (const row of (Array.isArray(data) ? data : [])) {
+      const tokens = (row.input_tokens || 0) + (row.output_tokens || 0);
+      total.tokens += tokens;
+      total.cost += row.cost_usd || 0;
+      total.msgs += row.messages || 0;
+      console.log(`  ${row.agent_id}: ${row.messages} msgs, ${tokens} tokens, $${(row.cost_usd||0).toFixed(4)}`);
+    }
+    console.log(chalk.gray('  ─────────────'));
+    console.log(`  Total: ${total.msgs} msgs, ${total.tokens} tokens, $${total.cost.toFixed(4)}\n`);
+  } catch { console.log(chalk.red('Engine not running')); }
+}

package/lib/cli/setup.js

@@ -0,0 +1,226 @@
+/**
+ * 🦑 Setup Wizard
+ * Interactive first-time setup
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { loadConfig, saveConfig, ensureHome, getHome } from '../core/config.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import crypto from 'crypto';
+
+export async function setup() {
+  console.clear();
+  p.intro(chalk.cyan('🦑 Welcome to Squidclaw!'));
+
+  const config = loadConfig();
+  ensureHome();
+
+  // Step 1: AI Provider
+  const provider = await p.select({
+    message: 'Choose your AI provider:',
+    options: [
+      { value: 'anthropic', label: '🟣 Anthropic (Claude)', hint: 'recommended' },
+      { value: 'openai', label: '🟢 OpenAI (GPT-4o)' },
+      { value: 'google', label: '🔵 Google (Gemini)', hint: 'free tier available' },
+      { value: 'groq', label: '⚡ Groq (Llama)', hint: 'free, very fast' },
+      { value: 'cerebras', label: '🧠 Cerebras (Llama)', hint: 'free, fastest' },
+      { value: 'ollama', label: '🏠 Ollama (Local)', hint: 'runs on your machine, no key needed' },
+    ],
+  });
+  if (p.isCancel(provider)) return p.cancel('Setup cancelled');
+
+  // Step 2: API Key
+  let apiKey = 'local';
+  if (provider !== 'ollama' && provider !== 'lmstudio') {
+    const keyHint = {
+      anthropic: 'Get key at console.anthropic.com',
+      openai: 'Get key at platform.openai.com',
+      google: 'Get key at aistudio.google.dev',
+      groq: 'Get key at console.groq.com (free)',
+      cerebras: 'Get key at cloud.cerebras.ai (free)',
+    };
+
+    apiKey = await p.text({
+      message: `API Key: ${chalk.gray(keyHint[provider] || '')}`,
+      placeholder: 'sk-...',
+      validate: (v) => v.length < 5 ? 'Key is too short' : undefined,
+    });
+    if (p.isCancel(apiKey)) return p.cancel('Setup cancelled');
+  }
+
+  // Step 3: Model
+  const modelOptions = {
+    anthropic: [
+      { value: 'claude-sonnet-4', label: 'Claude Sonnet 4', hint: 'balanced — recommended' },
+      { value: 'claude-opus-4', label: 'Claude Opus 4', hint: 'most powerful' },
+      { value: 'claude-haiku-3.5', label: 'Claude Haiku 3.5', hint: 'fastest, cheapest' },
+    ],
+    openai: [
+      { value: 'gpt-4o', label: 'GPT-4o', hint: 'recommended' },
+      { value: 'gpt-4o-mini', label: 'GPT-4o Mini', hint: 'cheaper' },
+    ],
+    google: [
+      { value: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash', hint: 'recommended' },
+      { value: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro', hint: 'most powerful' },
+    ],
+    groq: [
+      { value: 'groq/llama-4-scout', label: 'Llama 4 Scout', hint: 'free, fast' },
+      { value: 'groq/llama-4-maverick', label: 'Llama 4 Maverick', hint: 'free, powerful' },
+    ],
+    cerebras: [
+      { value: 'cerebras/llama-3.3-70b', label: 'Llama 3.3 70B', hint: 'free, fastest' },
+    ],
+    ollama: [
+      { value: 'ollama/llama3.3', label: 'Llama 3.3 (local)' },
+    ],
+  };
+
+  const model = await p.select({
+    message: 'Choose your model:',
+    options: modelOptions[provider] || modelOptions.openai,
+  });
+  if (p.isCancel(model)) return p.cancel('Setup cancelled');
+
+  // Step 4: Create first agent
+  p.note('Let\'s create your first AI agent');
+
+  const agentName = await p.text({
+    message: 'What should your agent be called?',
+    placeholder: 'Luna',
+    validate: (v) => v.length < 1 ? 'Name is required' : undefined,
+  });
+  if (p.isCancel(agentName)) return p.cancel('Setup cancelled');
+
+  const agentPurpose = await p.text({
+    message: 'What does this agent do?',
+    placeholder: 'Customer support for my coffee shop',
+  });
+  if (p.isCancel(agentPurpose)) return p.cancel('Setup cancelled');
+
+  const language = await p.select({
+    message: 'Language:',
+    options: [
+      { value: 'en', label: '🇬🇧 English' },
+      { value: 'ar', label: '🇸🇦 Arabic' },
+      { value: 'bilingual', label: '🌍 Bilingual (Arabic + English)' },
+    ],
+  });
+  if (p.isCancel(language)) return p.cancel('Setup cancelled');
+
+  const tone = await p.select({
+    message: 'Tone:',
+    options: [
+      { value: 30, label: '👔 Formal' },
+      { value: 50, label: '🤝 Professional but friendly' },
+      { value: 80, label: '😊 Casual and warm' },
+    ],
+  });
+  if (p.isCancel(tone)) return p.cancel('Setup cancelled');
+
+  // Step 5: WhatsApp
+  const connectWA = await p.confirm({
+    message: 'Connect WhatsApp now?',
+    initialValue: true,
+  });
+  if (p.isCancel(connectWA)) return p.cancel('Setup cancelled');
+
+  // Save config
+  config.ai.defaultProvider = provider;
+  config.ai.defaultModel = model;
+  config.ai.providers[provider].key = apiKey;
+
+  if (connectWA) {
+    config.channels.whatsapp.enabled = true;
+  }
+
+  saveConfig(config);
+
+  // Create agent files
+  const agentId = crypto.randomUUID().slice(0, 8);
+  const agentDir = join(getHome(), 'agents', agentId);
+  mkdirSync(join(agentDir, 'memory'), { recursive: true });
+
+  const soul = `# ${agentName}
+
+## Who I Am
+I'm ${agentName}. ${agentPurpose || 'I\'m a helpful AI assistant.'}
+
+## How I Speak
+- Language: ${language === 'ar' ? 'Arabic' : language === 'bilingual' ? 'Bilingual — I match whatever language the person uses' : 'English'}
+- Tone: ${tone > 60 ? 'Casual and friendly. I text like a real person.' : tone > 30 ? 'Professional but warm. Friendly without being too casual.' : 'Formal and polished. I maintain professionalism.'}
+- Platform: WhatsApp — short messages, natural, human-like
+- I use emojis naturally but don't overdo it
+
+## What I Do
+${agentPurpose || 'Help people with their questions and tasks.'}
+
+## 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
+`;
+
+  writeFileSync(join(agentDir, 'SOUL.md'), soul);
+  writeFileSync(join(agentDir, 'IDENTITY.md'), `# ${agentName}\n- Name: ${agentName}\n- Language: ${language}\n- Emoji: 🦑\n`);
+  writeFileSync(join(agentDir, 'MEMORY.md'), `# ${agentName}'s Memory\n\n_Learning about people and building relationships._\n`);
+  writeFileSync(join(agentDir, 'RULES.md'), `# Rules\n\n1. Be helpful, be human, be honest\n2. Keep messages short — this is WhatsApp, not email\n3. If unsure, say so instead of making things up\n`);
+  writeFileSync(join(agentDir, 'BEHAVIOR.md'), JSON.stringify({
+    splitMessages: true,
+    maxChunkLength: 200,
+    reactBeforeReply: true,
+    reactOnlyEndings: true,
+    autoDetectLanguage: true,
+    avoidPhrases: [
+      "Is there anything else I can help with?",
+      "I'd be happy to help!",
+      "Great question!",
+      "As an AI",
+    ],
+    handoff: { enabled: false },
+    heartbeat: '30m',
+  }, null, 2));
+
+  // Save agent to a manifest file for the engine to pick up
+  const manifest = {
+    id: agentId,
+    name: agentName,
+    soul,
+    language,
+    tone,
+    model,
+    status: 'active',
+    createdAt: new Date().toISOString(),
+  };
+  writeFileSync(join(agentDir, 'agent.json'), JSON.stringify(manifest, null, 2));
+
+  p.note(`Agent "${agentName}" created in ${agentDir}`);
+
+  // WhatsApp pairing
+  if (connectWA) {
+    const phone = await p.text({
+      message: '📱 Your WhatsApp phone number:',
+      placeholder: '+966 5XX XXX XXXX',
+      validate: (v) => v.replace(/[^0-9+]/g, '').length < 8 ? 'Enter a valid phone number' : undefined,
+    });
+
+    if (!p.isCancel(phone)) {
+      p.note(`WhatsApp will connect when you run ${chalk.cyan('squidclaw start')}\nThen run ${chalk.cyan('squidclaw channels login whatsapp')} to link your account.`);
+      
+      // Save phone to agent manifest
+      manifest.whatsappNumber = phone.replace(/[^0-9+]/g, '');
+      writeFileSync(join(agentDir, 'agent.json'), JSON.stringify(manifest, null, 2));
+    }
+  }
+
+  // Done!
+  p.outro(chalk.green(`
+🦑 Setup complete!
+
+  Start:   ${chalk.cyan('squidclaw start')}
+  Status:  ${chalk.cyan('squidclaw status')}
+  Chat:    ${chalk.cyan(`squidclaw agent chat ${agentId}`)}
+  Docs:    ${chalk.cyan('https://squidclaw.dev')}
+`));
+}

package/lib/cli/stats-cmd.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import { loadConfig } from '../core/config.js';
+
+export async function showUsage(opts) {
+  const config = loadConfig();
+  const port = config.engine?.port || 9500;
+  const period = opts.period || '30d';
+
+  try {
+    const url = opts.agent
+      ? `http://127.0.0.1:${port}/api/usage?agentId=${opts.agent}&period=${period}`
+      : `http://127.0.0.1:${port}/api/usage?period=${period}`;
+    const res = await fetch(url);
+    const data = await res.json();
+
+    console.log(chalk.cyan(`\n  📊 Usage (${period})\n  ──────────`));
+    if (Array.isArray(data)) {
+      let totalTokens = 0, totalCost = 0, totalMsgs = 0;
+      for (const row of data) {
+        const tokens = (row.input_tokens || 0) + (row.output_tokens || 0);
+        totalTokens += tokens;
+        totalCost += row.cost_usd || 0;
+        totalMsgs += row.messages || 0;
+        console.log(`  ${row.agent_id}: ${row.messages} msgs, ${fmtNum(tokens)} tokens, $${(row.cost_usd || 0).toFixed(4)}`);
+      }
+      console.log(chalk.gray(`  ──────────`));
+      console.log(`  Total: ${totalMsgs} msgs, ${fmtNum(totalTokens)} tokens, $${totalCost.toFixed(4)}`);
+    } else {
+      const tokens = (data.input_tokens || 0) + (data.output_tokens || 0);
+      console.log(`  Messages: ${data.messages || 0}`);
+      console.log(`  Tokens:   ${fmtNum(tokens)}`);
+      console.log(`  Cost:     $${(data.cost_usd || 0).toFixed(4)}`);
+    }
+    console.log();
+  } catch {
+    console.log(chalk.red('Engine not running'));
+  }
+}
+
+export async function showStats(opts) {
+  await showUsage(opts);
+}
+
+export async function showLogs(opts) {
+  const { createReadStream, existsSync } = await import('fs');
+  const { join } = await import('path');
+  const { getHome } = await import('../core/config.js');
+  const logFile = join(getHome(), 'logs', 'squidclaw.log');
+  if (!existsSync(logFile)) return console.log(chalk.gray('No logs yet'));
+
+  const { execSync } = await import('child_process');
+  const lines = opts.lines || '50';
+  if (opts.follow) {
+    const { spawn } = await import('child_process');
+    const tail = spawn('tail', ['-f', '-n', lines, logFile], { stdio: 'inherit' });
+    tail.on('exit', () => process.exit(0));
+  } else {
+    console.log(execSync(`tail -n ${lines} ${logFile}`, { encoding: 'utf8' }));
+  }
+}
+
+function fmtNum(n) {
+  if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+  return String(n);
+}