create-walle 0.1.0

package/template/wall-e/adapters/slack.js

@@ -0,0 +1,56 @@
+const AdapterBase = require('./adapter-base');
+
+class SlackAdapter extends AdapterBase {
+  constructor({ ownerNames = [] } = {}) {
+    super('slack');
+    this.ownerNames = ownerNames.map(n => n.toLowerCase());
+    this._pendingMessages = [];
+  }
+
+  feed(messages) {
+    this._pendingMessages.push(...messages);
+  }
+
+  async poll(since) {
+    const memories = this._pendingMessages
+      .map(msg => this.normalize(msg))
+      .filter(m => m !== null);
+
+    this._pendingMessages = [];
+
+    if (since) {
+      const sinceDate = new Date(since);
+      return memories.filter(m => new Date(m.timestamp) > sinceDate);
+    }
+
+    return memories;
+  }
+
+  normalize(rawData) {
+    if (!rawData) return null;
+    const { sender, text, channel, ts, permalink, thread_ts, timestamp } = rawData;
+
+    if (!text || !text.trim()) {
+      return null;
+    }
+
+    const isOwner = sender
+      ? this.ownerNames.includes(sender.toLowerCase())
+      : false;
+
+    return {
+      source: 'slack',
+      source_id: ts || `generated-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      source_channel: channel,
+      memory_type: isOwner ? 'message_sent' : 'message_received',
+      direction: isOwner ? 'outbound' : 'inbound',
+      participants: sender ? JSON.stringify([sender]) : null,
+      subject: thread_ts ? `thread:${thread_ts}` : null,
+      content: text.trim(),
+      metadata: JSON.stringify({ permalink, thread_ts }),
+      timestamp: timestamp || new Date().toISOString(),
+    };
+  }
+}
+
+module.exports = SlackAdapter;

package/template/wall-e/agent.js

@@ -0,0 +1,319 @@
+const brain = require('./brain'); // brain.js loads .env from project root
+const ingest = require('./loops/ingest');
+const think = require('./loops/think');
+const reflect = require('./loops/reflect');
+const { runDueSkills } = require('./skills/skill-planner');
+const { runDueTasks, recoverInterruptedTasks } = require('./loops/tasks');
+const CtmAdapter = require('./adapters/ctm');
+const SlackAdapter = require('./adapters/slack');
+const IMessageChannel = require('./channels/imessage-channel');
+const SlackChannel = require('./channels/slack-channel');
+const { chat: walleChat } = require('./chat');
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.join(__dirname, 'wall-e-config.json');
+const MIN_INTERVAL_MS = 10000; // 10 seconds minimum
+const MAX_INTERVAL_MS = 3600000; // 1 hour maximum
+
+// Guards against concurrent execution of async interval callbacks
+let ingestRunning = false;
+let thinkRunning = false;
+let reflectRunning = false;
+let skillsRunning = false;
+let shuttingDown = false;
+
+function loadOrCreateConfig() {
+  if (fs.existsSync(CONFIG_PATH)) {
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    // Sync owner name from env if config still has placeholder
+    const envName = process.env.WALLE_OWNER_NAME;
+    if (envName && config.owner && (config.owner.name === 'Unknown' || !config.owner.name)) {
+      const parts = envName.split(/\s+/);
+      config.owner.name = envName;
+      config.owner.first_name = parts[0];
+      config.owner.last_name = parts.slice(1).join(' ');
+      fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+      console.log(`[wall-e] Updated config owner from WALLE_OWNER_NAME env var.`);
+    }
+    return config;
+  }
+  // No config file — create from env or defaults
+  const envName = process.env.WALLE_OWNER_NAME || 'Unknown';
+  const parts = envName.split(/\s+/);
+  const config = {
+    owner: {
+      name: envName,
+      first_name: parts[0],
+      last_name: parts.slice(1).join(' '),
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    },
+    adapters: { ctm: { enabled: true }, slack: { enabled: !!process.env.SLACK_TOKEN } },
+    intervals: { ingest_ms: 60000, think_ms: 120000 },
+    channels: {
+      imessage: { enabled: false, buddy_id: '' },
+      slack_dm: { enabled: false, bot_token: '' },
+    },
+  };
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+  console.log(`[wall-e] Created config at ${CONFIG_PATH}`);
+  return config;
+}
+
+function clampInterval(value, fallback) {
+  const n = Number(value) || fallback;
+  return Math.max(MIN_INTERVAL_MS, Math.min(MAX_INTERVAL_MS, n));
+}
+
+function bootstrapSkills() {
+  const existing = brain.listSkills({});
+  if (existing.length > 0) return; // Already bootstrapped
+
+  brain.insertSkill({
+    name: 'scan-ctm-sessions',
+    description: 'Scan Claude Code session files for new conversations',
+    trigger_type: 'interval',
+    trigger_config: JSON.stringify({ interval_ms: 60000 }),
+    prompt_template: 'Scan the Claude Code session directory at ~/.claude/projects/ for any new or updated .jsonl session files. Read the most recently modified files and extract user messages and assistant responses as observations.',
+  });
+
+  brain.insertSkill({
+    name: 'learn-claude-code-skills',
+    description: 'Read Claude Code skills and MCP config to learn what tools are available',
+    trigger_type: 'interval',
+    trigger_config: JSON.stringify({ interval_ms: 3600000 }), // hourly
+    prompt_template: 'Read the Claude Code configuration at ~/.claude/settings.json and skill files at ~/.claude/skills/ to understand what MCP servers and skills are available. Summarize the capabilities as observations.',
+  });
+
+  brain.insertSkill({
+    name: 'ingest-slack-history',
+    description: 'Systematically pull all Slack conversation history (DMs, channels) going back 4 years',
+    trigger_type: 'interval',
+    trigger_config: JSON.stringify({ interval_ms: 30000 }), // Every 30s when active
+    prompt_template: 'INTERNAL_SKILL:slack-ingest', // Special marker -- not a Claude prompt
+    enabled: 0, // Disabled by default; start via UI or API
+  });
+
+  console.log('[wall-e] Bootstrapped initial skills');
+}
+
+async function main() {
+  console.log('[wall-e] Starting WALL-E agent daemon...');
+
+  if (!process.env.ANTHROPIC_API_KEY) {
+    console.warn('[wall-e] WARNING: ANTHROPIC_API_KEY not set — think/reflect loops will fail.');
+    console.warn('[wall-e] Copy .env.example to .env and add your API key.');
+  }
+
+  const config = loadOrCreateConfig();
+
+  // Init database (auto-creates data directory if needed)
+  brain.initDb();
+  brain.startDailyBackup();
+  bootstrapSkills();
+
+  // Set owner from config
+  if (config.owner) {
+    if (config.owner.name) brain.setOwner('name', String(config.owner.name).slice(0, 200));
+    if (config.owner.first_name) brain.setOwner('first_name', String(config.owner.first_name).slice(0, 100));
+    if (config.owner.last_name) brain.setOwner('last_name', String(config.owner.last_name).slice(0, 100));
+    if (config.owner.timezone) brain.setOwner('timezone', String(config.owner.timezone).slice(0, 50));
+  }
+  console.log(`[wall-e] Owner: ${brain.getOwnerName()}`);
+
+  // Build adapter list
+  const adapters = [];
+  if (config.adapters?.ctm?.enabled !== false) {
+    adapters.push(new CtmAdapter());
+    console.log('[wall-e] CTM adapter enabled');
+  }
+  if (config.adapters?.slack?.enabled) {
+    const ownerNames = [config.owner?.name, config.owner?.first_name].filter(Boolean);
+    adapters.push(new SlackAdapter({ ownerNames }));
+    console.log('[wall-e] Slack adapter enabled');
+  }
+  console.log(`[wall-e] ${adapters.length} adapter(s) active`);
+
+  // Initialize messaging channels
+  const channels = [];
+
+  if (config.channels?.imessage?.enabled && config.channels?.imessage?.buddy_id) {
+    const imsg = new IMessageChannel({
+      buddyId: config.channels.imessage.buddy_id,
+      onMessage: async (text, sender) => {
+        const result = await walleChat(text, { channel: 'imessage' });
+        return result.reply;
+      },
+    });
+    channels.push(imsg);
+    console.log('[wall-e] iMessage channel enabled');
+  }
+
+  if (config.channels?.slack_dm?.enabled) {
+    const slack = new SlackChannel({
+      botToken: config.channels.slack_dm.bot_token,
+      onMessage: async (text, sender) => {
+        const result = await walleChat(text, { channel: 'slack_dm' });
+        return result.reply;
+      },
+    });
+    channels.push(slack);
+    console.log('[wall-e] Slack DM channel enabled');
+  }
+
+  // Start all channels
+  for (const ch of channels) {
+    ch.start().catch(err => console.error(`[wall-e] Channel ${ch.name} start failed:`, err.message));
+  }
+  if (channels.length > 0) {
+    console.log(`[wall-e] ${channels.length} channel(s) started`);
+  }
+
+  // Always start HTTP server — WALL-E API should be independently reachable
+  const { startServer } = require('./server');
+  const httpServer = startServer();
+
+  // Recover tasks that were interrupted by previous shutdown
+  const recovered = recoverInterruptedTasks();
+  if (recovered > 0) console.log(`[wall-e] Recovered ${recovered} interrupted task(s)`);
+
+  // Initial ingest
+  console.log('[wall-e] Running initial ingest...');
+  const ingestResult = await ingest.runOnce(adapters);
+  console.log(`[wall-e] Initial ingest: ${ingestResult.memoriesIngested} memories`);
+
+  // Initial think
+  if (ingestResult.memoriesIngested > 0) {
+    console.log('[wall-e] Running initial think...');
+    const thinkResult = await think.runOnce();
+    console.log(`[wall-e] Initial think: ${thinkResult.memoriesProcessed} processed, ${thinkResult.knowledgeExtracted} knowledge`);
+  }
+
+  // Schedule loops with concurrency guards
+  const ingestMs = clampInterval(config.intervals?.ingest_ms, 60000);
+  const thinkMs = clampInterval(config.intervals?.think_ms, 120000);
+  const reflectMs = clampInterval(config.intervals?.reflect_ms, 3600000);
+
+  const ingestLoop = setInterval(async () => {
+    if (ingestRunning || shuttingDown) return;
+    ingestRunning = true;
+    try {
+      const result = await ingest.runOnce(adapters);
+      if (result.memoriesIngested > 0) {
+        console.log(`[wall-e] Ingested ${result.memoriesIngested} memories`);
+      }
+    } catch (err) {
+      console.error('[wall-e] Ingest error:', err.message);
+    } finally {
+      ingestRunning = false;
+    }
+  }, ingestMs);
+
+  const thinkLoop = setInterval(async () => {
+    if (thinkRunning || shuttingDown) return;
+    thinkRunning = true;
+    try {
+      const result = await think.runOnce();
+      if (result.knowledgeExtracted > 0) {
+        console.log(`[wall-e] Extracted ${result.knowledgeExtracted} knowledge entries`);
+      }
+    } catch (err) {
+      console.error('[wall-e] Think error:', err.message);
+    } finally {
+      thinkRunning = false;
+    }
+  }, thinkMs);
+
+  const reflectLoop = setInterval(async () => {
+    if (reflectRunning || shuttingDown) return;
+    reflectRunning = true;
+    try {
+      const result = await reflect.runOnce();
+      if (result.summaryGenerated) {
+        console.log('[wall-e] Daily summary generated');
+      }
+    } catch (err) {
+      console.error('[wall-e] Reflect error:', err.message);
+    } finally {
+      reflectRunning = false;
+    }
+  }, reflectMs);
+
+  // Skills loop
+  const skillMs = clampInterval(config.intervals?.skills_ms, 300000); // 5min default
+
+  const skillsLoop = setInterval(async () => {
+    if (skillsRunning || shuttingDown) return;
+    skillsRunning = true;
+    try {
+      const result = await runDueSkills();
+      if (result.executed > 0) {
+        console.log(`[wall-e] Skills: ${result.executed} executed, ${result.memoriesCreated} memories`);
+      }
+    } catch (err) {
+      console.error('[wall-e] Skills error:', err.message);
+    } finally {
+      skillsRunning = false;
+    }
+  }, skillMs);
+
+  // Task loop — check for due tasks every 30s
+  let tasksRunning = false;
+  const taskMs = clampInterval(config.intervals?.tasks_ms, 30000); // 30s default
+  const tasksLoop = setInterval(async () => {
+    if (tasksRunning || shuttingDown) return;
+    tasksRunning = true;
+    try {
+      const result = await runDueTasks();
+      if (result.processed > 0) {
+        console.log(`[wall-e] Tasks: ${result.processed} completed`);
+      }
+    } catch (err) {
+      console.error('[wall-e] Tasks error:', err.message);
+    } finally {
+      tasksRunning = false;
+    }
+  }, taskMs);
+
+  console.log(`[wall-e] Daemon running. Ingest every ${ingestMs / 1000}s, Think every ${thinkMs / 1000}s, Reflect every ${reflectMs / 1000}s, Skills every ${skillMs / 1000}s, Tasks every ${taskMs / 1000}s.`);
+  console.log('[wall-e] Press Ctrl+C to stop.');
+
+  // Graceful shutdown — wait for in-flight operations
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log('\n[wall-e] Shutting down...');
+    clearInterval(ingestLoop);
+    clearInterval(thinkLoop);
+    clearInterval(reflectLoop);
+    clearInterval(skillsLoop);
+    clearInterval(tasksLoop);
+
+    // Stop all channels
+    for (const ch of channels) {
+      try { await ch.stop(); } catch {}
+    }
+
+    // Wait up to 5s for in-flight operations
+    const deadline = Date.now() + 5000;
+    while ((ingestRunning || thinkRunning || reflectRunning || skillsRunning || tasksRunning) && Date.now() < deadline) {
+      await new Promise(r => setTimeout(r, 100));
+    }
+    if (ingestRunning || thinkRunning || reflectRunning || skillsRunning) {
+      console.warn('[wall-e] Force closing with operations still in-flight');
+    }
+
+    try { require('./skills/mcp-client').disconnectAll(); } catch {}
+    if (httpServer) httpServer.close();
+    brain.closeDb();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch(err => {
+  console.error('[wall-e] Fatal:', err);
+  try { brain.closeDb(); } catch {}
+  process.exit(1);
+});