squidclaw 1.4.0 → 1.5.0

package/lib/engine.js

@@ -62,6 +62,8 @@ export class SquidclawEngine {
     pipeline.use('media', mediaMiddleware);
     pipeline.use('auto-links', autoLinksMiddleware);
     pipeline.use('auto-memory', autoMemoryMiddleware);
+    const { configChatMiddleware } = await import('./middleware/config-chat.js');
+    pipeline.use('config-chat', configChatMiddleware);
     pipeline.use('skill-check', skillCheckMiddleware);
     pipeline.use('typing', typingMiddleware);        // wraps AI call with typing indicator
     pipeline.use('ai-process', aiProcessMiddleware);
@@ -136,7 +138,13 @@ export class SquidclawEngine {
     // 5. Features (reminders, auto-memory, usage alerts)
     await this._initFeatures();
 
-    // 5b. Sub-agents
+    // 5b. Config Manager
+    try {
+      const { ConfigManager } = await import('./features/config-manager.js');
+      this.configManager = new ConfigManager(this);
+    } catch {}
+
+    // 5c. Sub-agents
     try {
       const { SubAgentManager } = await import('./features/sub-agents.js');
       this.subAgents = new SubAgentManager(this);

package/lib/features/config-manager.js

@@ -0,0 +1,238 @@
+/**
+ * 🦑 Config Manager
+ * Hot reload, chat commands, .env support, profiles, validation
+ */
+
+import { loadConfig, saveConfig, getHome } from '../core/config.js';
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../core/logger.js';
+
+export class ConfigManager {
+  constructor(engine) {
+    this.engine = engine;
+    this.home = getHome();
+    this._loadEnv();
+    this._watchConfig();
+  }
+
+  // ── .env support ──
+
+  _loadEnv() {
+    const envPath = join(this.home, '.env');
+    if (!existsSync(envPath)) return;
+
+    try {
+      const lines = readFileSync(envPath, 'utf8').split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+        process.env[key] = value;
+      }
+      logger.info('config', 'Loaded .env file');
+    } catch {}
+  }
+
+  // ── Hot reload ──
+
+  _watchConfig() {
+    const configPath = join(this.home, 'config.json');
+    try {
+      const { watch } = require('fs');
+      let debounce = null;
+      watch(configPath, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(() => {
+          try {
+            this.engine.config = loadConfig();
+            logger.info('config', 'Config hot-reloaded');
+          } catch (err) {
+            logger.error('config', 'Hot reload failed: ' + err.message);
+          }
+        }, 1000);
+      });
+    } catch {
+      // fs.watch not available — use polling
+      this._pollConfig(configPath);
+    }
+  }
+
+  _pollConfig(configPath) {
+    let lastMtime = 0;
+    try { lastMtime = readFileSync(configPath).length; } catch {}
+    
+    setInterval(() => {
+      try {
+        const content = readFileSync(configPath, 'utf8');
+        if (content.length !== lastMtime) {
+          lastMtime = content.length;
+          this.engine.config = loadConfig();
+          logger.info('config', 'Config hot-reloaded (poll)');
+        }
+      } catch {}
+    }, 5000);
+  }
+
+  // ── Set config value ──
+
+  set(path, value) {
+    const config = loadConfig();
+    const parts = path.split('.');
+    let obj = config;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!obj[parts[i]]) obj[parts[i]] = {};
+      obj = obj[parts[i]];
+    }
+
+    // Auto-convert types
+    if (value === 'true') value = true;
+    else if (value === 'false') value = false;
+    else if (!isNaN(value) && value !== '') value = Number(value);
+
+    obj[parts[parts.length - 1]] = value;
+    saveConfig(config);
+    this.engine.config = config;
+
+    logger.info('config', `Set ${path} = ${JSON.stringify(value)}`);
+    return { path, value };
+  }
+
+  // ── Get config value ──
+
+  get(path) {
+    const config = loadConfig();
+    const parts = path.split('.');
+    let obj = config;
+
+    for (const part of parts) {
+      if (obj === undefined) return undefined;
+      obj = obj[part];
+    }
+
+    return obj;
+  }
+
+  // ── Profiles ──
+
+  saveProfile(name) {
+    const configPath = join(this.home, 'config.json');
+    const profilePath = join(this.home, `config.${name}.json`);
+    copyFileSync(configPath, profilePath);
+    return profilePath;
+  }
+
+  loadProfile(name) {
+    const profilePath = join(this.home, `config.${name}.json`);
+    if (!existsSync(profilePath)) throw new Error('Profile not found: ' + name);
+    
+    const configPath = join(this.home, 'config.json');
+    copyFileSync(profilePath, configPath);
+    this.engine.config = loadConfig();
+    return true;
+  }
+
+  listProfiles() {
+    const { readdirSync } = require('fs');
+    return readdirSync(this.home)
+      .filter(f => f.startsWith('config.') && f.endsWith('.json') && f !== 'config.json')
+      .map(f => f.replace('config.', '').replace('.json', ''));
+  }
+
+  // ── Validation ──
+
+  async validate() {
+    const config = loadConfig();
+    const results = [];
+
+    // Check AI providers
+    const providers = config.ai?.providers || {};
+    for (const [name, prov] of Object.entries(providers)) {
+      if (!prov.key || prov.key === 'local') continue;
+      
+      try {
+        const valid = await this._testProvider(name, prov.key);
+        results.push({ name, status: valid ? '✅' : '❌', message: valid ? 'Valid' : 'Invalid key' });
+      } catch (err) {
+        results.push({ name, status: '❌', message: err.message });
+      }
+    }
+
+    // Check Telegram
+    if (config.channels?.telegram?.token) {
+      try {
+        const res = await fetch(`https://api.telegram.org/bot${config.channels.telegram.token}/getMe`);
+        const data = await res.json();
+        results.push({ name: 'Telegram', status: data.ok ? '✅' : '❌', message: data.ok ? '@' + data.result.username : 'Invalid token' });
+      } catch (err) {
+        results.push({ name: 'Telegram', status: '❌', message: err.message });
+      }
+    }
+
+    // Check agents
+    const agentsDir = join(this.home, 'agents');
+    if (existsSync(agentsDir)) {
+      const { readdirSync } = require('fs');
+      const count = readdirSync(agentsDir, { withFileTypes: true }).filter(d => d.isDirectory()).length;
+      results.push({ name: 'Agents', status: '✅', message: count + ' configured' });
+    }
+
+    return results;
+  }
+
+  async _testProvider(name, key) {
+    const urls = {
+      anthropic: 'https://api.anthropic.com/v1/models',
+      openai: 'https://api.openai.com/v1/models',
+      google: `https://generativelanguage.googleapis.com/v1beta/models?key=${key}`,
+      groq: 'https://api.groq.com/openai/v1/models',
+    };
+
+    const url = urls[name];
+    if (!url) return true; // Can't validate, assume OK
+
+    const headers = {};
+    if (name === 'anthropic') {
+      headers['x-api-key'] = key;
+      headers['anthropic-version'] = '2023-06-01';
+    } else if (name !== 'google') {
+      headers['Authorization'] = 'Bearer ' + key;
+    }
+
+    const res = await fetch(url, { headers });
+    return res.ok;
+  }
+
+  // ── Chat command parsing ──
+
+  static parseConfigCommand(message) {
+    const lower = message.toLowerCase().trim();
+
+    // "switch to gpt-4o" / "use gemini"
+    const modelMatch = lower.match(/(?:switch|change|use)\s+(?:to\s+)?(?:model\s+)?(.+)/);
+    if (modelMatch) {
+      const model = modelMatch[1].trim();
+      // Map common names to actual model IDs
+      const aliases = {
+        'gpt4': 'gpt-4o', 'gpt-4': 'gpt-4o', 'gpt4o': 'gpt-4o',
+        'claude': 'claude-sonnet-4-20250514', 'sonnet': 'claude-sonnet-4-20250514',
+        'opus': 'claude-opus-4', 'haiku': 'claude-haiku-3-5',
+        'gemini': 'gemini-2.5-flash', 'flash': 'gemini-2.5-flash',
+        'llama': 'llama-3.3-70b-versatile', 'deepseek': 'deepseek-chat',
+      };
+      return { action: 'set_model', model: aliases[model] || model };
+    }
+
+    // "set temperature to 0.8"
+    const setMatch = lower.match(/set\s+(\w[\w.]*)\s+(?:to\s+)?(.+)/);
+    if (setMatch) {
+      return { action: 'set', path: setMatch[1], value: setMatch[2] };
+    }
+
+    return null;
+  }
+}

package/lib/middleware/commands.js

@@ -16,7 +16,8 @@ export async function commandsMiddleware(ctx, next) {
       '/memories — what I remember about you',
       '/tasks — your todo list',
       '/usage — spending report',
-      '/exec <cmd> — run a shell command',
+      '/config — manage settings',
+              '/exec <cmd> — run a shell command',
               '/files — list sandbox files',
               '/subagents — list background tasks',
               '/help — this message',
@@ -120,6 +121,71 @@ export async function commandsMiddleware(ctx, next) {
     return;
   }
 
+  if (cmd === '/config') {
+    const args = msg.slice(8).trim();
+    if (!args || args === 'help') {
+      await ctx.reply([
+        '⚙️ *Config Commands*', '',
+        '/config get <path> — show value',
+        '/config set <path> <value> — set value',
+        '/config test — validate all connections',
+        '/config profiles — list saved profiles',
+        '/config save <name> — save current config',
+        '/config load <name> — switch profile',
+        '', 'Or just say: "switch to gemini" 🦑',
+      ].join('\n'));
+      return;
+    }
+
+    const cm = ctx.engine.configManager;
+    if (!cm) { await ctx.reply('❌ Config manager not available'); return; }
+
+    if (args.startsWith('get ')) {
+      const val = cm.get(args.slice(4).trim());
+      await ctx.reply('⚙️ ' + args.slice(4).trim() + ' = ' + JSON.stringify(val));
+      return;
+    }
+
+    if (args.startsWith('set ')) {
+      const parts = args.slice(4).trim().split(/\s+/);
+      const path = parts[0];
+      const value = parts.slice(1).join(' ');
+      cm.set(path, value);
+      await ctx.reply('✅ Set *' + path + '* = ' + value);
+      return;
+    }
+
+    if (args === 'test' || args === 'validate') {
+      await ctx.reply('🔍 Validating connections...');
+      const results = await cm.validate();
+      const lines = results.map(r => r.status + ' *' + r.name + '* — ' + r.message);
+      await ctx.reply('⚙️ *Config Validation*\n\n' + lines.join('\n'));
+      return;
+    }
+
+    if (args === 'profiles') {
+      const profiles = cm.listProfiles();
+      await ctx.reply(profiles.length ? '📋 Profiles: ' + profiles.join(', ') : '📋 No saved profiles');
+      return;
+    }
+
+    if (args.startsWith('save ')) {
+      cm.saveProfile(args.slice(5).trim());
+      await ctx.reply('✅ Profile saved: ' + args.slice(5).trim());
+      return;
+    }
+
+    if (args.startsWith('load ')) {
+      try {
+        cm.loadProfile(args.slice(5).trim());
+        await ctx.reply('✅ Profile loaded: ' + args.slice(5).trim() + '\n⚠️ Restart recommended');
+      } catch (err) {
+        await ctx.reply('❌ ' + err.message);
+      }
+      return;
+    }
+  }
+
   if (cmd === '/exec') {
     const command = msg.slice(6).trim();
     if (!command) { await ctx.reply('Usage: /exec <command>'); return; }

package/lib/middleware/config-chat.js

@@ -0,0 +1,35 @@
+/**
+ * Handle config changes via natural language
+ * "switch to gemini", "use gpt-4o", "set temperature to 0.8"
+ */
+import { logger } from '../core/logger.js';
+
+export async function configChatMiddleware(ctx, next) {
+  if (!ctx.engine.configManager) { await next(); return; }
+
+  const { ConfigManager } = await import('../features/config-manager.js');
+  const parsed = ConfigManager.parseConfigCommand(ctx.message);
+  
+  if (!parsed) { await next(); return; }
+
+  try {
+    if (parsed.action === 'set_model') {
+      ctx.engine.configManager.set('ai.defaultModel', parsed.model);
+      // Update agent's model too
+      if (ctx.agent) ctx.agent.model = parsed.model;
+      await ctx.reply('✅ Model switched to *' + parsed.model + '*\n\nI will use this model from now on 🦑');
+      return;
+    }
+
+    if (parsed.action === 'set') {
+      ctx.engine.configManager.set(parsed.path, parsed.value);
+      await ctx.reply('✅ Set *' + parsed.path + '* = ' + parsed.value);
+      return;
+    }
+  } catch (err) {
+    await ctx.reply('❌ Config error: ' + err.message);
+    return;
+  }
+
+  await next();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squidclaw",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "🦑 AI agent platform — human-like agents for WhatsApp, Telegram & more",
   "main": "lib/engine.js",
   "bin": {