obol-ai 0.1.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "obol-ai",
+  "version": "0.1.0",
+  "description": "Self-evolving AI assistant that learns, remembers, and acts on its own. Persistent vector memory, self-rewriting personality, proactive heartbeats.",
+  "main": "src/index.js",
+  "bin": {
+    "obol": "./bin/obol.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node tests/run.js"
+  },
+  "keywords": ["ai", "assistant", "telegram", "anthropic", "claude", "vector-memory"],
+  "author": "Jo Vinkenroye <jestersimpps@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@supabase/supabase-js": "^2.49.1",
+    "@xenova/transformers": "^2.17.2",
+    "grammy": "^1.35.0",
+    "commander": "^13.1.0",
+    "inquirer": "^9.2.12",
+    "open": "^10.1.0",
+    "node-cron": "^3.0.3"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/background.js

@@ -0,0 +1,188 @@
+/**
+ * Background task runner with progress check-ins.
+ * 
+ * Main conversation stays responsive. Heavy tasks run in background.
+ * Claude periodically reports progress back to the user.
+ */
+
+const CHECK_IN_INTERVAL = 30000; // 30 seconds
+
+class BackgroundRunner {
+  constructor() {
+    this.tasks = new Map(); // taskId -> { promise, status, progress, chatId }
+    this.taskCounter = 0;
+  }
+
+  /**
+   * Spawn a background task. Returns immediately.
+   * @param {object} claude - Claude client
+   * @param {string} task - The task description
+   * @param {object} ctx - Telegram context (for sending updates)
+   * @param {object} memory - Memory instance
+   */
+  spawn(claude, task, ctx, memory) {
+    const taskId = ++this.taskCounter;
+    const chatId = ctx.chat.id;
+
+    const taskState = {
+      id: taskId,
+      task,
+      chatId,
+      status: 'running',
+      progress: [],
+      startedAt: Date.now(),
+    };
+
+    this.tasks.set(taskId, taskState);
+
+    // Run the task
+    const promise = this._runTask(claude, task, taskState, ctx, memory);
+
+    taskState.promise = promise;
+
+    // Start check-in timer
+    taskState.checkInTimer = setInterval(async () => {
+      if (taskState.status !== 'running') {
+        clearInterval(taskState.checkInTimer);
+        return;
+      }
+
+      const elapsed = Math.floor((Date.now() - taskState.startedAt) / 1000);
+      await this._checkIn(claude, taskState, ctx, elapsed);
+    }, CHECK_IN_INTERVAL);
+
+    return taskId;
+  }
+
+  async _runTask(claude, task, taskState, ctx, memory) {
+    try {
+      // Give the background task a system instruction to report progress
+      const bgPrompt = `You are working on a background task. Do the work thoroughly.
+
+After EVERY tool call, update your internal progress by including a brief status line like:
+"[PROGRESS] Searched 5 dental clinics, now checking reviews..."
+
+This helps track what you're doing. Complete the full task, then give the final result.
+
+TASK: ${task}`;
+
+      const result = await claude.chat(bgPrompt, {
+        chatId: `bg-${taskState.id}`,
+        userName: 'BackgroundTask',
+      });
+
+      taskState.status = 'done';
+      taskState.result = result;
+      clearInterval(taskState.checkInTimer);
+
+      // Send final result
+      const elapsed = Math.floor((Date.now() - taskState.startedAt) / 1000);
+      const header = `✅ Done! (${formatDuration(elapsed)})\n\n`;
+
+      await sendLong(ctx, header + result);
+
+      // Store to memory
+      if (memory) {
+        await memory.add(`Background task completed: "${task.substring(0, 100)}". Took ${elapsed}s.`, {
+          category: 'context',
+          source: 'background-task',
+        }).catch(() => {});
+      }
+
+      // Cleanup after 5 min
+      setTimeout(() => this.tasks.delete(taskState.id), 300000);
+
+    } catch (e) {
+      taskState.status = 'error';
+      taskState.error = e.message;
+      clearInterval(taskState.checkInTimer);
+
+      await ctx.reply(`⚠️ Background task failed: ${e.message}`).catch(() => {});
+    }
+  }
+
+  async _checkIn(claude, taskState, ctx, elapsed) {
+    try {
+      // Ask Claude for a brief status update based on what it's been doing
+      const checkInPrompt = `You have a background task running for ${elapsed}s: "${taskState.task}"
+
+Give a ONE LINE progress update (emoji + what's happening). Be specific about what you've found/done so far. Example: "⏳ Found 8 clinics, comparing ratings and prices..."`;
+
+      // Use a separate quick call — don't interfere with the main task
+      const update = await claude.chat(checkInPrompt, {
+        chatId: `checkin-${taskState.id}-${elapsed}`,
+        userName: 'CheckIn',
+      });
+
+      if (update && update.trim()) {
+        await ctx.reply(update.trim()).catch(() => {});
+      }
+    } catch {
+      // Check-in failed — not critical, skip it
+    }
+  }
+
+  /**
+   * Get status of all running tasks
+   */
+  getStatus() {
+    const running = [];
+    for (const [id, task] of this.tasks) {
+      if (task.status === 'running') {
+        const elapsed = Math.floor((Date.now() - task.startedAt) / 1000);
+        running.push({
+          id,
+          task: task.task.substring(0, 80),
+          elapsed: formatDuration(elapsed),
+        });
+      }
+    }
+    return running;
+  }
+
+  /**
+   * Check if there are running tasks
+   */
+  hasRunningTasks() {
+    for (const task of this.tasks.values()) {
+      if (task.status === 'running') return true;
+    }
+    return false;
+  }
+}
+
+function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const min = Math.floor(seconds / 60);
+  const sec = seconds % 60;
+  return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
+}
+
+async function sendLong(ctx, text) {
+  if (text.length <= 4096) {
+    await ctx.reply(text, { parse_mode: 'Markdown' }).catch(() =>
+      ctx.reply(text)
+    );
+    return;
+  }
+
+  // Split on newlines
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= 4096) {
+      await ctx.reply(remaining, { parse_mode: 'Markdown' }).catch(() =>
+        ctx.reply(remaining)
+      );
+      break;
+    }
+    let splitAt = remaining.lastIndexOf('\n', 4096);
+    if (splitAt === -1 || splitAt < 2000) splitAt = 4096;
+    const chunk = remaining.substring(0, splitAt);
+    await ctx.reply(chunk, { parse_mode: 'Markdown' }).catch(() =>
+      ctx.reply(chunk)
+    );
+    remaining = remaining.substring(splitAt).trimStart();
+  }
+}
+
+module.exports = { BackgroundRunner };

package/src/backup.js

@@ -0,0 +1,66 @@
+const cron = require('node-cron');
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { OBOL_DIR } = require('./config');
+
+function setupBackup(githubConfig) {
+  const { token, username, repo } = githubConfig;
+  const backupDir = path.join(OBOL_DIR, '.backup-repo');
+
+  // Daily backup at 3 AM
+  cron.schedule('0 3 * * *', async () => {
+    try {
+      await runBackup(githubConfig);
+      console.log(`[${new Date().toISOString()}] Backup complete`);
+    } catch (e) {
+      console.error(`[${new Date().toISOString()}] Backup failed: ${e.message}`);
+    }
+  });
+
+  console.log('  ✅ GitHub backup scheduled (daily 3 AM)');
+}
+
+async function runBackup(githubConfig, commitMessage) {
+  const { token, username, repo } = githubConfig;
+  const backupDir = path.join(OBOL_DIR, '.backup-repo');
+  const repoUrl = `https://${token}@github.com/${username}/${repo}.git`;
+
+  // Clone or pull
+  if (!fs.existsSync(path.join(backupDir, '.git'))) {
+    execSync(`git clone ${repoUrl} ${backupDir}`, { stdio: 'pipe' });
+  } else {
+    execSync('git pull', { cwd: backupDir, stdio: 'pipe' });
+  }
+
+  // Set git identity
+  execSync('git config user.name "OBOL"', { cwd: backupDir });
+  execSync('git config user.email "obol@backup"', { cwd: backupDir });
+
+  // Sync files (exclude secrets)
+  const syncDirs = ['personality', 'scripts', 'tests', 'commands', 'apps'];
+  for (const dir of syncDirs) {
+    const src = path.join(OBOL_DIR, dir);
+    const dst = path.join(backupDir, dir);
+    if (fs.existsSync(src)) {
+      execSync(`mkdir -p ${dst} && cp -r ${src}/* ${dst}/ 2>/dev/null || true`, { stdio: 'pipe' });
+    }
+  }
+
+  // Commit and push
+  execSync('git add -A', { cwd: backupDir, stdio: 'pipe' });
+
+  try {
+    const status = execSync('git status --porcelain', { cwd: backupDir, encoding: 'utf-8' });
+    if (status.trim()) {
+      const date = new Date().toISOString().slice(0, 10);
+      const msg = commitMessage || `backup: ${date}`;
+      execSync(`git commit -m "${msg}"`, { cwd: backupDir, stdio: 'pipe' });
+      execSync('git push', { cwd: backupDir, stdio: 'pipe' });
+    }
+  } catch {
+    // Nothing to commit
+  }
+}
+
+module.exports = { setupBackup, runBackup };