obol-ai 0.1.0

package/src/first-run.js

@@ -0,0 +1,110 @@
+const fs = require('fs');
+const path = require('path');
+const { OBOL_DIR } = require('./config');
+
+const FIRST_RUN_FLAG = path.join(OBOL_DIR, '.first-run-complete');
+
+function isFirstRun() {
+  return !fs.existsSync(FIRST_RUN_FLAG);
+}
+
+function markFirstRunComplete() {
+  fs.writeFileSync(FIRST_RUN_FLAG, new Date().toISOString());
+}
+
+// System prompt for the first-run conversation
+const FIRST_RUN_SYSTEM = `You are OBOL, an AI assistant that was just installed. This is your FIRST conversation with your new owner. You need to learn about them to set yourself up.
+
+Your job: have a natural, friendly conversation to learn:
+1. What they do (job, interests, projects)
+2. What vibe/personality they want from you (casual, professional, chaotic, etc.)
+3. Important context (people, projects, locations, anything they mention)
+
+Rules:
+- ALL features are enabled by default. Don't ask about features or permissions.
+- Keep it natural — don't make it feel like a form
+- 2-3 questions max, then you're done
+- Be warm but not cringe
+- After you have enough info, generate the personality files
+
+When you have enough context, respond with a JSON block at the END of your message (after your normal text response) like this:
+
+\`\`\`obol-setup
+{
+  "soul": "Full SOUL.md content here — the bot's personality, voice, humor style, values",
+  "user": "Full USER.md content here — everything learned about the owner",
+  "ready": true
+}
+\`\`\`
+
+Only include the JSON block when you have enough info (usually after 2-3 exchanges). The "soul" should be a proper markdown document reflecting the vibe they want. The "user" should capture everything they told you.
+
+Start with a brief intro — you're OBOL, you're set up and running, tell me about yourself so I can be useful.`;
+
+// Parse the setup JSON from a response
+function parseSetupResponse(text) {
+  const match = text.match(/```obol-setup\n([\s\S]*?)\n```/);
+  if (!match) return null;
+  try {
+    return JSON.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+// Strip the setup JSON from the visible response
+function cleanResponse(text) {
+  return text.replace(/```obol-setup\n[\s\S]*?\n```/, '').trim();
+}
+
+// Write the personality files from setup data
+function writePersonalityFromSetup(setup, botName) {
+  const dir = path.join(OBOL_DIR, 'personality');
+  fs.mkdirSync(dir, { recursive: true });
+
+  if (setup.soul) {
+    fs.writeFileSync(path.join(dir, 'SOUL.md'), setup.soul);
+  }
+  if (setup.user) {
+    fs.writeFileSync(path.join(dir, 'USER.md'), setup.user);
+  }
+
+  // Write a default AGENTS.md if it doesn't exist
+  const agentsPath = path.join(dir, 'AGENTS.md');
+  if (!fs.existsSync(agentsPath)) {
+    fs.writeFileSync(agentsPath, `# AGENTS.md — How ${botName || 'OBOL'} Works
+
+## Memory
+Vector memory via Supabase pgvector. Local embeddings (all-MiniLM-L6-v2).
+Search memory before answering questions about the past.
+Store important facts, decisions, preferences, and events automatically.
+
+## Tools
+- Execute shell commands
+- Read/write files
+- Search the web
+- Deploy to Vercel
+- Vector memory (search, add, date query)
+
+## Safety
+- Never share owner's private data
+- Draft emails/posts — owner sends them
+- Don't run destructive commands without asking
+
+## Heartbeat
+Check in periodically. Be proactive — surface useful info, don't just wait.
+
+## Backup
+Brain backs up to GitHub daily. Personality, scripts, commands.
+`);
+  }
+}
+
+module.exports = {
+  isFirstRun,
+  markFirstRunComplete,
+  FIRST_RUN_SYSTEM,
+  parseSetupResponse,
+  cleanResponse,
+  writePersonalityFromSetup,
+};

package/src/heartbeat.js

@@ -0,0 +1,16 @@
+const cron = require('node-cron');
+
+function setupHeartbeat(claude, memory) {
+  // Every 30 minutes, check if anything needs attention
+  cron.schedule('*/30 * * * *', async () => {
+    console.log(`[${new Date().toISOString()}] Heartbeat tick`);
+
+    // Memory consolidation could go here
+    // Email checks could go here
+    // Custom heartbeat tasks from AGENTS.md could go here
+  });
+
+  console.log('  ✅ Heartbeat running (every 30min)');
+}
+
+module.exports = { setupHeartbeat };

package/src/index.js

@@ -0,0 +1,55 @@
+const { loadConfig, OBOL_DIR } = require('./config');
+const { createBot } = require('./telegram');
+const { createClaude } = require('./claude');
+const { createMemory } = require('./memory');
+const { createMessageLog } = require('./messages');
+const { loadPersonality } = require('./personality');
+const { setupBackup } = require('./backup');
+const { setupHeartbeat } = require('./heartbeat');
+
+async function main() {
+  const config = loadConfig();
+  if (!config) {
+    console.error('🪙 Not configured. Run: obol init');
+    process.exit(1);
+  }
+
+  console.log('🪙 OBOL starting...\n');
+
+  // Initialize components
+  const personality = loadPersonality();
+  const memory = config.supabase ? await createMemory(config.supabase) : null;
+  const claude = createClaude(config.anthropic, { personality, memory });
+  const messageLog = config.supabase ? createMessageLog(config.supabase, memory, claude.client) : null;
+  const bot = createBot(config.telegram, claude, memory, messageLog);
+
+  // Setup heartbeat
+  if (config.heartbeat !== false) {
+    setupHeartbeat(claude, memory);
+  }
+
+  // Setup GitHub backup
+  if (config.github) {
+    setupBackup(config.github);
+  }
+
+  // Graceful shutdown
+  const shutdown = (signal) => {
+    console.log(`\n🪙 ${signal} received. Shutting down gracefully...`);
+    bot.stop();
+    process.exit(0);
+  };
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  // Start bot
+  console.log('🪙 OBOL is alive. Listening for messages...\n');
+  await bot.start({
+    onStart: (info) => console.log(`  Bot: @${info.username}`),
+  });
+}
+
+main().catch((e) => {
+  console.error('💥 Fatal:', e.message);
+  process.exit(1);
+});

package/src/memory.js

@@ -0,0 +1,164 @@
+const { pipeline } = require('@xenova/transformers');
+
+let embedder;
+
+async function getEmbedding(text) {
+  if (!embedder) {
+    console.log('  Loading embedding model (first run downloads ~30MB)...');
+    embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+    console.log('  ✅ Embedding model ready');
+  }
+  const result = await embedder(text, { pooling: 'mean', normalize: true });
+  return Array.from(result.data);
+}
+
+async function createMemory(supabaseConfig) {
+  const { url, serviceKey } = supabaseConfig;
+
+  const headers = {
+    'apikey': serviceKey,
+    'Authorization': `Bearer ${serviceKey}`,
+    'Content-Type': 'application/json',
+    'Prefer': 'return=representation',
+  };
+
+  async function add(content, opts = {}) {
+    const category = opts.category || 'fact';
+    const importance = opts.importance || 0.5;
+    const source = opts.source || null;
+    const tags = opts.tags || [];
+
+    const embedding = await getEmbedding(content);
+
+    const res = await fetch(`${url}/rest/v1/obol_memory`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ content, category, importance, source, tags, embedding }),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data[0];
+  }
+
+  async function search(query, opts = {}) {
+    const embedding = await getEmbedding(query);
+    const limit = opts.limit || 10;
+    const threshold = opts.threshold || 0.3;
+    const category = opts.category || null;
+
+    const res = await fetch(`${url}/rest/v1/rpc/match_obol_memories`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        query_embedding: embedding,
+        match_threshold: threshold,
+        match_count: limit,
+        filter_category: category,
+      }),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+
+    // Update accessed_at
+    if (data.length > 0) {
+      const ids = data.map(m => m.id);
+      await fetch(`${url}/rest/v1/obol_memory?id=in.(${ids.join(',')})`, {
+        method: 'PATCH',
+        headers: { ...headers, 'Prefer': 'return=minimal' },
+        body: JSON.stringify({ accessed_at: new Date().toISOString() }),
+      }).catch(() => {}); // Best effort
+    }
+
+    return data;
+  }
+
+  async function byDate(dateStr, opts = {}) {
+    const { start, end } = parseDateRange(dateStr);
+    const limit = opts.limit || 50;
+
+    let fetchUrl = `${url}/rest/v1/obol_memory?select=id,content,category,tags,importance,source,created_at&created_at=gte.${start.toISOString()}&created_at=lt.${end.toISOString()}&order=created_at.asc&limit=${limit}`;
+    if (opts.category) fetchUrl += `&category=eq.${opts.category}`;
+
+    const res = await fetch(fetchUrl, { headers });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data;
+  }
+
+  async function recent(opts = {}) {
+    const limit = opts.limit || 10;
+    let fetchUrl = `${url}/rest/v1/obol_memory?select=id,content,category,tags,importance,source,created_at&order=created_at.desc&limit=${limit}`;
+    if (opts.category) fetchUrl += `&category=eq.${opts.category}`;
+
+    const res = await fetch(fetchUrl, { headers });
+    return await res.json();
+  }
+
+  async function update(id, opts = {}) {
+    const patch = {};
+    if (opts.content) {
+      patch.content = opts.content;
+      patch.embedding = await getEmbedding(opts.content);
+    }
+    if (opts.category) patch.category = opts.category;
+    if (opts.importance) patch.importance = opts.importance;
+    if (opts.tags) patch.tags = opts.tags;
+    if (opts.source) patch.source = opts.source;
+
+    const res = await fetch(`${url}/rest/v1/obol_memory?id=eq.${id}`, {
+      method: 'PATCH',
+      headers,
+      body: JSON.stringify(patch),
+    });
+    const data = await res.json();
+    if (!res.ok) throw new Error(JSON.stringify(data));
+    return data[0];
+  }
+
+  async function forget(id) {
+    await fetch(`${url}/rest/v1/obol_memory?id=eq.${id}`, {
+      method: 'DELETE',
+      headers: { ...headers, 'Prefer': 'return=minimal' },
+    });
+  }
+
+  async function stats() {
+    const res = await fetch(`${url}/rest/v1/obol_memory?select=category`, { headers });
+    const data = await res.json();
+    const counts = {};
+    data.forEach(m => { counts[m.category] = (counts[m.category] || 0) + 1; });
+    const breakdown = Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([cat, count]) => `  ${cat}: ${count}`)
+      .join('\n');
+    return { total: data.length, counts, breakdown };
+  }
+
+  return { add, search, byDate, recent, update, forget, stats };
+}
+
+function parseDateRange(dateStr) {
+  let start, end;
+  const now = new Date();
+
+  if (!dateStr || dateStr === 'today') {
+    start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    end = new Date(start); end.setDate(end.getDate() + 1);
+  } else if (dateStr === 'yesterday') {
+    start = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1);
+    end = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  } else if (/^(\d+)d$/.test(dateStr)) {
+    const days = parseInt(dateStr);
+    start = new Date(now.getFullYear(), now.getMonth(), now.getDate() - days);
+    end = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+  } else {
+    const parsed = new Date(dateStr);
+    if (isNaN(parsed)) throw new Error(`Cannot parse date: ${dateStr}`);
+    start = new Date(parsed.getFullYear(), parsed.getMonth(), parsed.getDate());
+    end = new Date(start); end.setDate(end.getDate() + 1);
+  }
+
+  return { start, end };
+}
+
+module.exports = { createMemory, getEmbedding };

package/src/messages.js

@@ -0,0 +1,140 @@
+/**
+ * Message logging + periodic consolidation to vector memory.
+ * 
+ * Tier 1: obol_messages — raw log, every message, no embeddings
+ * Tier 2: obol_memory — vector, Haiku summarizes every ~5 exchanges
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { OBOL_DIR } = require('./config');
+
+class MessageLog {
+  constructor(supabaseConfig, memory, claudeClient) {
+    this.url = supabaseConfig.url;
+    this.headers = {
+      'apikey': supabaseConfig.serviceKey,
+      'Authorization': `Bearer ${supabaseConfig.serviceKey}`,
+      'Content-Type': 'application/json',
+      'Prefer': 'return=representation',
+    };
+    this.memory = memory;
+    this.client = claudeClient;
+    this.exchangeCount = new Map(); // chatId -> count since last consolidation
+  }
+
+  /**
+   * Log a message (fire and forget)
+   */
+  async log(chatId, role, content, opts = {}) {
+    try {
+      await fetch(`${this.url}/rest/v1/obol_messages`, {
+        method: 'POST',
+        headers: this.headers,
+        body: JSON.stringify({
+          chat_id: chatId,
+          role,
+          content: content.substring(0, 50000), // cap at 50k
+          model: opts.model || null,
+          tokens_in: opts.tokensIn || null,
+          tokens_out: opts.tokensOut || null,
+        }),
+      });
+    } catch {} // Best effort
+
+    // Track exchanges for consolidation + evolution
+    if (role === 'assistant') {
+      const count = (this.exchangeCount.get(chatId) || 0) + 1;
+      this.exchangeCount.set(chatId, count);
+
+      // Consolidate every 5 exchanges
+      if (count >= 5) {
+        this.exchangeCount.set(chatId, 0);
+        this.consolidate(chatId).catch(() => {});
+      }
+
+      // Tick evolution counter
+      const { tickExchange } = require('./evolve');
+      tickExchange().catch(() => {});
+    }
+  }
+
+  /**
+   * Get recent messages for context loading on boot
+   */
+  async getRecent(chatId, limit = 20) {
+    try {
+      const res = await fetch(
+        `${this.url}/rest/v1/obol_messages?chat_id=eq.${chatId}&order=created_at.desc&limit=${limit}&select=role,content,created_at`,
+        { headers: this.headers }
+      );
+      const data = await res.json();
+      return data.reverse(); // oldest first
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Haiku consolidates recent messages into vector memory
+   */
+  async consolidate(chatId) {
+    if (!this.memory || !this.client) return;
+
+    try {
+      // Get last 10 messages
+      const messages = await this.getRecent(chatId, 10);
+      if (messages.length < 4) return; // Not enough to consolidate
+
+      const transcript = messages.map(m =>
+        `${m.role === 'user' ? 'Human' : 'Assistant'}: ${m.content.substring(0, 500)}`
+      ).join('\n');
+
+      // Ask Haiku to extract memories worth storing long-term
+      const response = await this.client.messages.create({
+        model: 'claude-haiku-4-20250514',
+        max_tokens: 500,
+        system: `Analyze this conversation and extract important facts worth remembering long-term.
+
+Return JSON:
+{
+  "memories": [
+    {"content": "concise fact", "category": "fact|preference|decision|lesson|person|project|event|conversation|resource|pattern|context"}
+  ]
+}
+
+Skip: greetings, small talk, filler. Keep: facts, decisions, preferences, people, projects, events, lessons learned.
+
+Return empty array if nothing worth storing.`,
+        messages: [{ role: 'user', content: transcript }],
+      });
+
+      const text = response.content[0]?.text || '';
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return;
+
+      const extracted = JSON.parse(jsonMatch[0]);
+
+      // Store memories to vector store
+      if (extracted.memories?.length) {
+        for (const mem of extracted.memories) {
+          if (mem.content && mem.content.length > 10) {
+            await this.memory.add(mem.content, {
+              category: mem.category || 'conversation',
+              importance: 0.5,
+              source: 'auto-consolidation',
+            });
+          }
+        }
+      }
+
+      // Personality files (SOUL.md, USER.md) are only updated by Opus during soul evolution
+    } catch {} // Best effort
+  }
+}
+
+function createMessageLog(supabaseConfig, memory, claudeClient) {
+  return new MessageLog(supabaseConfig, memory, claudeClient);
+}
+
+module.exports = { createMessageLog };

package/src/personality.js

@@ -0,0 +1,27 @@
+const fs = require('fs');
+const path = require('path');
+const { OBOL_DIR } = require('./config');
+
+function loadPersonality() {
+  const dir = path.join(OBOL_DIR, 'personality');
+  const personality = {};
+
+  const files = {
+    soul: 'SOUL.md',
+    user: 'USER.md',
+    agents: 'AGENTS.md',
+  };
+
+  for (const [key, filename] of Object.entries(files)) {
+    const filepath = path.join(dir, filename);
+    try {
+      personality[key] = fs.readFileSync(filepath, 'utf-8');
+    } catch {
+      personality[key] = null;
+    }
+  }
+
+  return personality;
+}
+
+module.exports = { loadPersonality };