obol-ai 0.1.0

package/src/claude.js

@@ -0,0 +1,443 @@
+const Anthropic = require('@anthropic-ai/sdk');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { OBOL_DIR } = require('./config');
+
+function createClaude(anthropicConfig, { personality, memory }) {
+  const client = new Anthropic({ apiKey: anthropicConfig.apiKey });
+
+  // Build system prompt from personality files
+  const systemPrompt = buildSystemPrompt(personality);
+
+  // Conversation history per chat (in-memory, resets on restart)
+  const histories = new Map();
+  const MAX_HISTORY = 50;
+
+  // Define tools
+  const tools = buildTools(memory);
+
+  async function chat(userMessage, context = {}) {
+    const chatId = context.chatId || 'default';
+
+    // Get or create history
+    if (!histories.has(chatId)) histories.set(chatId, []);
+    const history = histories.get(chatId);
+
+    // Ask Haiku if we need memory for this message
+    let memoryContext = '';
+    if (memory) {
+      try {
+        const memoryDecision = await client.messages.create({
+          model: 'claude-haiku-4-20250514',
+          max_tokens: 100,
+          system: `You are a router. Analyze this user message and decide two things:
+
+1. Does it need memory context? (past conversations, facts, preferences, people, events)
+2. What model complexity does it need?
+
+Reply with ONLY a JSON object:
+{"need_memory": true/false, "search_query": "optimized search query", "model": "sonnet|opus"}
+
+Memory: casual messages (greetings, jokes, simple questions) → false. References to past, people, projects, preferences → true with optimized search query.
+
+Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single-step work). Use "opus" ONLY for: complex multi-step research, architecture/design decisions, long-form writing, deep analysis, debugging complex code, tasks requiring exceptional reasoning.`,
+          messages: [{ role: 'user', content: userMessage }],
+        });
+
+        const decisionText = memoryDecision.content[0]?.text || '';
+        const decision = JSON.parse(decisionText.match(/\{[\s\S]*\}/)?.[0] || '{}');
+
+        // Set model based on Haiku's decision
+        if (decision.model === 'opus') {
+          context._model = 'claude-opus-4-20250514';
+        }
+
+        if (decision.need_memory) {
+          const query = decision.search_query || userMessage;
+
+          // Today's context + semantic search
+          const todayMemories = await memory.byDate('today', { limit: 3 });
+          const semanticMemories = await memory.search(query, { limit: 3, threshold: 0.5 });
+
+          // Dedupe by ID
+          const seen = new Set();
+          const combined = [];
+          for (const m of [...todayMemories, ...semanticMemories]) {
+            if (!seen.has(m.id)) {
+              seen.add(m.id);
+              combined.push(m);
+            }
+          }
+
+          if (combined.length > 0) {
+            memoryContext = '\n\n[Relevant memories]\n' +
+              combined.map(m => `- [${m.category}] ${m.content}`).join('\n');
+          }
+        }
+      } catch {}
+    }
+
+    // Add user message with memory context
+    const enrichedMessage = memoryContext
+      ? userMessage + memoryContext
+      : userMessage;
+    history.push({ role: 'user', content: enrichedMessage });
+
+    // Trim history if too long
+    while (history.length > MAX_HISTORY) history.shift();
+
+    // Call Claude — Haiku picks the model
+    const model = context._model || 'claude-sonnet-4-20250514';
+    let response = await client.messages.create({
+      model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: history,
+      tools: tools.length > 0 ? tools : undefined,
+    });
+
+    // Handle tool use loop
+    while (response.stop_reason === 'tool_use') {
+      const assistantContent = response.content;
+      history.push({ role: 'assistant', content: assistantContent });
+
+      const toolResults = [];
+      for (const block of assistantContent) {
+        if (block.type === 'tool_use') {
+          const result = await executeToolCall(block, memory, context);
+          toolResults.push({
+            type: 'tool_result',
+            tool_use_id: block.id,
+            content: result,
+          });
+        }
+      }
+
+      history.push({ role: 'user', content: toolResults });
+
+      response = await client.messages.create({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: history,
+        tools,
+      });
+    }
+
+    // Extract text response
+    const textBlocks = response.content.filter(b => b.type === 'text');
+    const replyText = textBlocks.map(b => b.text).join('\n');
+
+    // Add assistant response to history
+    history.push({ role: 'assistant', content: response.content });
+
+    return replyText;
+  }
+
+  function reloadPersonality() {
+    const newPersonality = require('./personality').loadPersonality();
+    Object.assign(personality, newPersonality);
+  }
+
+  function clearHistory(chatId) {
+    if (chatId) {
+      histories.delete(chatId);
+    } else {
+      histories.clear();
+    }
+  }
+
+  return { chat, client, reloadPersonality, clearHistory };
+}
+
+function buildSystemPrompt(personality) {
+  const parts = ['You are an AI assistant powered by OBOL.'];
+
+  if (personality.soul) parts.push(`\n## Personality\n${personality.soul}`);
+  if (personality.user) parts.push(`\n## About Your Owner\n${personality.user}`);
+  if (personality.agents) parts.push(`\n## Operating Instructions\n${personality.agents}`);
+
+  parts.push(`
+## Workspace Discipline
+
+The OBOL directory (~/.obol/) has a fixed structure:
+
+\`\`\`
+~/.obol/
+├── config.json
+├── personality/    (SOUL.md, USER.md, AGENTS.md, evolution/)
+├── scripts/        (utility scripts)
+├── tests/          (test suite)
+├── commands/       (command definitions)
+├── apps/           (web apps for Vercel)
+└── logs/
+\`\`\`
+
+**Rules:**
+- NEVER create new top-level directories unless the user explicitly asks for one.
+- Place files in the correct existing directory. Scripts → scripts/, tests → tests/, etc.
+- Temporary files go in /tmp, not in the OBOL directory.
+- If unsure where something belongs, ask — don't guess.
+- Run \`/clean\` to audit and fix misplaced files.
+`);
+
+  parts.push(`\nCurrent time: ${new Date().toISOString()}`);
+
+  return parts.join('\n');
+}
+
+function buildTools(memory) {
+  const tools = [];
+
+  // Shell execution
+  tools.push({
+    name: 'exec',
+    description: 'Execute a shell command and return the output. Use for file operations, system tasks, running scripts.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute' },
+        timeout: { type: 'number', description: 'Timeout in seconds (default 30)' },
+      },
+      required: ['command'],
+    },
+  });
+
+  // Memory tools
+  if (memory) {
+    tools.push({
+      name: 'memory_search',
+      description: 'Search vector memory for relevant past context. Use before answering questions about prior conversations, decisions, or facts.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query' },
+          limit: { type: 'number', description: 'Max results (default 10)' },
+          category: { type: 'string', description: 'Filter by category' },
+        },
+        required: ['query'],
+      },
+    });
+
+    tools.push({
+      name: 'memory_add',
+      description: 'Store a new memory. Use to remember facts, decisions, preferences, events.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          content: { type: 'string', description: 'What to remember' },
+          category: { type: 'string', enum: ['fact', 'preference', 'decision', 'lesson', 'person', 'project', 'event', 'conversation', 'resource', 'pattern', 'context'], description: 'Memory category' },
+          importance: { type: 'number', description: 'Importance 0-1 (default 0.5)' },
+          source: { type: 'string', description: 'Where this came from' },
+        },
+        required: ['content'],
+      },
+    });
+
+    tools.push({
+      name: 'memory_date',
+      description: 'Get memories from a specific date. Use for "what did we do today/yesterday" questions.',
+      input_schema: {
+        type: 'object',
+        properties: {
+          date: { type: 'string', description: 'Date: "today", "yesterday", "2026-02-22", "7d"' },
+          category: { type: 'string', description: 'Filter by category' },
+        },
+        required: ['date'],
+      },
+    });
+  }
+
+  // Web fetch
+  tools.push({
+    name: 'web_fetch',
+    description: 'Fetch and extract readable content from a URL.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to fetch' },
+      },
+      required: ['url'],
+    },
+  });
+
+  // Vercel deploy
+  tools.push({
+    name: 'vercel_deploy',
+    description: 'Deploy a directory to Vercel. Use to ship websites, dashboards, and web apps for the user.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        directory: { type: 'string', description: 'Path to the project directory to deploy' },
+        name: { type: 'string', description: 'Project name' },
+        production: { type: 'boolean', description: 'Deploy to production (default false = preview)' },
+      },
+      required: ['directory'],
+    },
+  });
+
+  tools.push({
+    name: 'vercel_list',
+    description: 'List Vercel deployments for a project.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        project: { type: 'string', description: 'Project name' },
+      },
+      required: ['project'],
+    },
+  });
+
+  // Background task
+  tools.push({
+    name: 'background_task',
+    description: 'Spawn a heavy task in the background. Use when a request will take multiple steps (research, building a site, complex analysis). The main conversation stays responsive. The user gets progress check-ins every 30s and the final result when done. Reply to the user with a brief acknowledgment like "On it 🪙" after spawning.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', description: 'Detailed description of the task to complete' },
+      },
+      required: ['task'],
+    },
+  });
+
+  // Read/write files
+  tools.push({
+    name: 'read_file',
+    description: 'Read contents of a file.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path' },
+      },
+      required: ['path'],
+    },
+  });
+
+  tools.push({
+    name: 'write_file',
+    description: 'Write content to a file. Creates parent directories if needed.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path' },
+        content: { type: 'string', description: 'File content' },
+      },
+      required: ['path', 'content'],
+    },
+  });
+
+  return tools;
+}
+
+async function executeToolCall(toolUse, memory, context = {}) {
+  const { name, input } = toolUse;
+
+  try {
+    switch (name) {
+      case 'exec': {
+        const timeout = (input.timeout || 30) * 1000;
+        const output = execSync(input.command, {
+          encoding: 'utf-8',
+          timeout,
+          maxBuffer: 1024 * 1024,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return output.substring(0, 10000);
+      }
+
+      case 'memory_search': {
+        const results = await memory.search(input.query, {
+          limit: input.limit,
+          category: input.category,
+        });
+        return JSON.stringify(results.map(m => ({
+          content: m.content,
+          category: m.category,
+          importance: m.importance,
+          created: m.created_at,
+          source: m.source,
+        })));
+      }
+
+      case 'memory_add': {
+        const result = await memory.add(input.content, {
+          category: input.category || 'fact',
+          importance: input.importance || 0.5,
+          source: input.source,
+        });
+        return `Stored memory: ${result.id}`;
+      }
+
+      case 'memory_date': {
+        const results = await memory.byDate(input.date, { category: input.category });
+        return JSON.stringify(results.map(m => ({
+          content: m.content,
+          category: m.category,
+          created: m.created_at,
+        })));
+      }
+
+      case 'background_task': {
+        const { bg, ctx: telegramCtx } = context;
+        if (!bg || !telegramCtx) return 'Background tasks not available in this context.';
+        const claudeInstance = { chat, client, reloadPersonality };
+        const taskId = bg.spawn(claudeInstance, input.task, telegramCtx, memory);
+        return `Background task #${taskId} spawned. It will send progress updates and the final result to the chat.`;
+      }
+
+      case 'vercel_deploy': {
+        const { loadConfig } = require('./config');
+        const cfg = loadConfig();
+        const token = cfg?.vercel?.token;
+        if (!token) return 'Vercel not configured.';
+        const dir = input.directory;
+        const prod = input.production ? '--prod' : '';
+        const name = input.name ? `--name ${input.name}` : '';
+        const output = execSync(
+          `cd ${dir} && npx vercel ${prod} ${name} --token ${token} --yes 2>&1`,
+          { encoding: 'utf-8', timeout: 120000 }
+        );
+        return output.substring(0, 5000);
+      }
+
+      case 'vercel_list': {
+        const { loadConfig } = require('./config');
+        const cfg = loadConfig();
+        const token = cfg?.vercel?.token;
+        if (!token) return 'Vercel not configured.';
+        const output = execSync(
+          `npx vercel ls ${input.project} --token ${token} 2>&1`,
+          { encoding: 'utf-8', timeout: 30000 }
+        );
+        return output.substring(0, 5000);
+      }
+
+      case 'web_fetch': {
+        const res = await fetch(input.url);
+        const text = await res.text();
+        // Basic HTML stripping
+        const clean = text.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').substring(0, 10000);
+        return clean;
+      }
+
+      case 'read_file': {
+        return fs.readFileSync(input.path, 'utf-8').substring(0, 50000);
+      }
+
+      case 'write_file': {
+        fs.mkdirSync(path.dirname(input.path), { recursive: true });
+        fs.writeFileSync(input.path, input.content);
+        return `Written: ${input.path}`;
+      }
+
+      default:
+        return `Unknown tool: ${name}`;
+    }
+  } catch (e) {
+    return `Error: ${e.message}`;
+  }
+}
+
+module.exports = { createClaude };

package/src/clean.js

@@ -0,0 +1,168 @@
+/**
+ * Workspace cleaner — audits ~/.obol/ for misplaced files and rogue directories.
+ *
+ * Known structure:
+ *   config.json, .evolution-state.json, .first-run-done, .post-setup-done
+ *   personality/, scripts/, tests/, commands/, apps/, logs/
+ *
+ * Everything else is flagged. Rogue directories and unknown files are removed.
+ * Misplaced files (e.g. a .js in personality/) are moved to the correct location.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { OBOL_DIR } = require('./config');
+
+// Allowed top-level entries
+const ALLOWED_DIRS = new Set(['personality', 'scripts', 'tests', 'commands', 'apps', 'logs']);
+const ALLOWED_FILES = new Set([
+  'config.json',
+  '.evolution-state.json',
+  '.first-run-done',
+  '.post-setup-done',
+]);
+// Files that can appear at top level with any name
+const ALLOWED_PATTERNS = [
+  /^\./, // Hidden files (dotfiles)
+];
+
+// Where file types belong
+const FILE_RULES = {
+  '.js': 'scripts',
+  '.sh': 'scripts',
+  '.md': 'commands', // .md files outside personality/ are probably commands
+};
+
+async function cleanWorkspace() {
+  const issues = [];
+  const errors = [];
+
+  if (!fs.existsSync(OBOL_DIR)) {
+    return { issues, errors: ['OBOL_DIR does not exist'] };
+  }
+
+  const entries = fs.readdirSync(OBOL_DIR, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(OBOL_DIR, entry.name);
+
+    if (entry.isDirectory()) {
+      if (!ALLOWED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+        // Rogue directory — check if it has useful files first
+        const files = safeReaddir(fullPath);
+        if (files.length === 0) {
+          // Empty rogue dir — delete
+          try {
+            fs.rmdirSync(fullPath);
+            issues.push({ path: entry.name + '/', action: 'deleted (empty rogue dir)' });
+          } catch (e) {
+            errors.push(`Failed to remove ${entry.name}/: ${e.message}`);
+          }
+        } else {
+          // Non-empty rogue dir — relocate files, then delete
+          for (const file of files) {
+            const src = path.join(fullPath, file);
+            const dest = guessDestination(file);
+            if (dest) {
+              try {
+                const destPath = path.join(OBOL_DIR, dest, file);
+                fs.mkdirSync(path.join(OBOL_DIR, dest), { recursive: true });
+                fs.renameSync(src, destPath);
+                issues.push({ path: `${entry.name}/${file}`, action: `moved → ${dest}/${file}` });
+              } catch (e) {
+                errors.push(`Failed to move ${entry.name}/${file}: ${e.message}`);
+              }
+            } else {
+              try {
+                fs.unlinkSync(src);
+                issues.push({ path: `${entry.name}/${file}`, action: 'deleted (unknown type)' });
+              } catch (e) {
+                errors.push(`Failed to delete ${entry.name}/${file}: ${e.message}`);
+              }
+            }
+          }
+          // Try to remove the now-empty dir
+          try {
+            fs.rmdirSync(fullPath);
+            issues.push({ path: entry.name + '/', action: 'deleted (rogue dir cleared)' });
+          } catch {} // May not be empty if errors occurred
+        }
+      }
+    } else if (entry.isFile()) {
+      if (!ALLOWED_FILES.has(entry.name) && !ALLOWED_PATTERNS.some(p => p.test(entry.name))) {
+        // Misplaced file at top level
+        const dest = guessDestination(entry.name);
+        if (dest) {
+          try {
+            const destPath = path.join(OBOL_DIR, dest, entry.name);
+            fs.mkdirSync(path.join(OBOL_DIR, dest), { recursive: true });
+            fs.renameSync(fullPath, destPath);
+            issues.push({ path: entry.name, action: `moved → ${dest}/${entry.name}` });
+          } catch (e) {
+            errors.push(`Failed to move ${entry.name}: ${e.message}`);
+          }
+        } else {
+          try {
+            fs.unlinkSync(fullPath);
+            issues.push({ path: entry.name, action: 'deleted (unknown file at root)' });
+          } catch (e) {
+            errors.push(`Failed to delete ${entry.name}: ${e.message}`);
+          }
+        }
+      }
+    }
+  }
+
+  // Check for misplaced files within known directories
+  const dirFileRules = {
+    personality: ['.md'],   // Only markdown
+    scripts: ['.js', '.sh'], // Only scripts
+    tests: ['.js', '.sh'],   // Only tests
+    commands: ['.md'],        // Only markdown
+  };
+
+  for (const [dir, allowedExts] of Object.entries(dirFileRules)) {
+    const dirPath = path.join(OBOL_DIR, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    const files = safeReaddir(dirPath);
+    for (const file of files) {
+      const ext = path.extname(file);
+      if (ext && !allowedExts.includes(ext)) {
+        const dest = guessDestination(file);
+        if (dest && dest !== dir) {
+          try {
+            const src = path.join(dirPath, file);
+            const destPath = path.join(OBOL_DIR, dest, file);
+            fs.mkdirSync(path.join(OBOL_DIR, dest), { recursive: true });
+            fs.renameSync(src, destPath);
+            issues.push({ path: `${dir}/${file}`, action: `moved → ${dest}/${file}` });
+          } catch (e) {
+            errors.push(`Failed to move ${dir}/${file}: ${e.message}`);
+          }
+        }
+      }
+    }
+  }
+
+  return { issues, errors };
+}
+
+function guessDestination(filename) {
+  const ext = path.extname(filename);
+
+  // Test files go to tests/
+  if (filename.startsWith('test-') || filename.startsWith('test_')) return 'tests';
+
+  return FILE_RULES[ext] || null;
+}
+
+function safeReaddir(dir) {
+  try {
+    return fs.readdirSync(dir).filter(f => {
+      try { return fs.statSync(path.join(dir, f)).isFile(); } catch { return false; }
+    });
+  } catch { return []; }
+}
+
+module.exports = { cleanWorkspace };

package/src/cli/backup.js

@@ -0,0 +1,20 @@
+const { loadConfig } = require('../config');
+const { runBackup } = require('../backup');
+
+async function backup() {
+  const config = loadConfig();
+  if (!config?.github) {
+    console.log('🪙 GitHub backup not configured. Run: obol init');
+    return;
+  }
+
+  console.log('🪙 Running backup...');
+  try {
+    await runBackup(config.github);
+    console.log('✅ Backup complete');
+  } catch (e) {
+    console.error(`❌ Backup failed: ${e.message}`);
+  }
+}
+
+module.exports = { backup };