kernelbot 1.0.30 → 1.0.32

package/src/bot.js

@@ -53,7 +53,8 @@ class ChatQueue {
   }
 }
 
-export function startBot(config, agent, conversationManager, jobManager, automationManager) {
+export function startBot(config, agent, conversationManager, jobManager, automationManager, lifeDeps = {}) {
+  const { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge } = lifeDeps;
   const logger = getLogger();
   const bot = new TelegramBot(config.telegram.bot_token, { polling: true });
   const chatQueue = new ChatQueue();
@@ -87,6 +88,10 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     { command: 'jobs', description: 'List running and recent jobs' },
     { command: 'cancel', description: 'Cancel running job(s)' },
     { command: 'auto', description: 'Manage recurring automations' },
+    { command: 'life', description: 'Inner life engine status and control' },
+    { command: 'journal', description: 'View today\'s journal or a past date' },
+    { command: 'memories', description: 'View recent memories or search' },
+    { command: 'evolution', description: 'Self-evolution status, history, and lessons' },
     { command: 'context', description: 'Show all models, auth, and context info' },
     { command: 'clean', description: 'Clear conversation and start fresh' },
     { command: 'history', description: 'Show message count in memory' },
@@ -125,7 +130,7 @@ export function startBot(config, agent, conversationManager, jobManager, automat
               });
               return edited.message_id;
             } catch {
-              return opts.editMessageId;
+              // Edit failed — fall through to send new message
             }
           }
         }
@@ -1100,6 +1105,296 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       return;
     }
 
+    // ── /life command ──────────────────────────────────────────────
+    if (text === '/life' || text.startsWith('/life ')) {
+      logger.info(`[Bot] /life command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/life'.length).trim();
+
+      if (!lifeEngine) {
+        await bot.sendMessage(chatId, 'Life engine is not available.');
+        return;
+      }
+
+      if (args === 'pause') {
+        lifeEngine.pause();
+        await bot.sendMessage(chatId, '⏸️ Inner life paused. Use `/life resume` to restart.', { parse_mode: 'Markdown' });
+        return;
+      }
+      if (args === 'resume') {
+        lifeEngine.resume();
+        await bot.sendMessage(chatId, '▶️ Inner life resumed!');
+        return;
+      }
+      if (args.startsWith('trigger')) {
+        const activityType = args.split(/\s+/)[1] || null;
+        const validTypes = ['think', 'browse', 'journal', 'create', 'self_code', 'code_review', 'reflect'];
+        if (activityType && !validTypes.includes(activityType)) {
+          await bot.sendMessage(chatId, `Unknown activity type. Available: ${validTypes.join(', ')}`);
+          return;
+        }
+        await bot.sendMessage(chatId, `⚡ Triggering ${activityType || 'random'} activity...`);
+        lifeEngine.triggerNow(activityType).catch(err => {
+          logger.error(`[Bot] Life trigger failed: ${err.message}`);
+        });
+        return;
+      }
+      if (args === 'review') {
+        if (evolutionTracker) {
+          const active = evolutionTracker.getActiveProposal();
+          const openPRs = evolutionTracker.getPRsToCheck();
+          const lines = ['*Evolution Status*', ''];
+          if (active) {
+            lines.push(`Active: \`${active.id}\` — ${active.status}`);
+            lines.push(`  ${(active.triggerContext || '').slice(0, 150)}`);
+          } else {
+            lines.push('_No active proposals._');
+          }
+          if (openPRs.length > 0) {
+            lines.push('', '*Open PRs:*');
+            for (const p of openPRs) {
+              lines.push(`  • PR #${p.prNumber}: ${p.prUrl || 'no URL'}`);
+            }
+          }
+          lines.push('', '_Use `/evolution` for full evolution status._');
+          await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        } else {
+          await bot.sendMessage(chatId, 'Evolution system not available. Use `/evolution` for details.', { parse_mode: 'Markdown' });
+        }
+        return;
+      }
+
+      // Default: show status
+      const status = lifeEngine.getStatus();
+      const lines = [
+        '🌱 *Inner Life*',
+        '',
+        `*Status:* ${status.paused ? '⏸️ Paused' : status.status === 'active' ? '🟢 Active' : '⚪ Idle'}`,
+        `*Total activities:* ${status.totalActivities}`,
+        `*Last activity:* ${status.lastActivity || 'none'} (${status.lastActivityAgo})`,
+        `*Last wake-up:* ${status.lastWakeUpAgo}`,
+        '',
+        '*Activity counts:*',
+        `  💭 Think: ${status.activityCounts.think || 0}`,
+        `  🌐 Browse: ${status.activityCounts.browse || 0}`,
+        `  📓 Journal: ${status.activityCounts.journal || 0}`,
+        `  🎨 Create: ${status.activityCounts.create || 0}`,
+        `  🔧 Self-code: ${status.activityCounts.self_code || 0}`,
+        `  🔍 Code review: ${status.activityCounts.code_review || 0}`,
+        `  🪞 Reflect: ${status.activityCounts.reflect || 0}`,
+        '',
+        '_Commands:_',
+        '`/life pause` — Pause activities',
+        '`/life resume` — Resume activities',
+        '`/life trigger [think|browse|journal|create|self_code|code_review|reflect]` — Trigger now',
+      ];
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /journal command ─────────────────────────────────────────
+    if (text === '/journal' || text.startsWith('/journal ')) {
+      logger.info(`[Bot] /journal command from ${username} (${userId}) in chat ${chatId}`);
+
+      if (!journalManager) {
+        await bot.sendMessage(chatId, 'Journal system is not available.');
+        return;
+      }
+
+      const args = text.slice('/journal'.length).trim();
+
+      if (args && /^\d{4}-\d{2}-\d{2}$/.test(args)) {
+        const entry = journalManager.getEntry(args);
+        if (!entry) {
+          await bot.sendMessage(chatId, `No journal entry for ${args}.`);
+          return;
+        }
+        const chunks = splitMessage(entry);
+        for (const chunk of chunks) {
+          try { await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' }); }
+          catch { await bot.sendMessage(chatId, chunk); }
+        }
+        return;
+      }
+
+      if (args === 'list') {
+        const dates = journalManager.list(15);
+        if (dates.length === 0) {
+          await bot.sendMessage(chatId, 'No journal entries yet.');
+          return;
+        }
+        const lines = ['📓 *Journal Entries*', '', ...dates.map(d => `  • \`${d}\``)];
+        lines.push('', '_Use `/journal YYYY-MM-DD` to read an entry._');
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // Default: show today's journal
+      const today = journalManager.getToday();
+      if (!today) {
+        await bot.sendMessage(chatId, '📓 No journal entries today yet.\n\n_Use `/journal list` to see past entries._', { parse_mode: 'Markdown' });
+        return;
+      }
+      const chunks = splitMessage(today);
+      for (const chunk of chunks) {
+        try { await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' }); }
+        catch { await bot.sendMessage(chatId, chunk); }
+      }
+      return;
+    }
+
+    // ── /memories command ────────────────────────────────────────
+    if (text === '/memories' || text.startsWith('/memories ')) {
+      logger.info(`[Bot] /memories command from ${username} (${userId}) in chat ${chatId}`);
+
+      if (!memoryManager) {
+        await bot.sendMessage(chatId, 'Memory system is not available.');
+        return;
+      }
+
+      const args = text.slice('/memories'.length).trim();
+
+      if (args.startsWith('about ')) {
+        const query = args.slice('about '.length).trim();
+        const results = memoryManager.searchEpisodic(query, 10);
+        if (results.length === 0) {
+          await bot.sendMessage(chatId, `No memories matching "${query}".`);
+          return;
+        }
+        const lines = [`🧠 *Memories about "${query}"*`, ''];
+        for (const m of results) {
+          const date = new Date(m.timestamp).toLocaleDateString();
+          lines.push(`• ${m.summary} _(${date}, importance: ${m.importance})_`);
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      // Default: show last 10 memories
+      const recent = memoryManager.getRecentEpisodic(168, 10); // last 7 days
+      if (recent.length === 0) {
+        await bot.sendMessage(chatId, '🧠 No memories yet.');
+        return;
+      }
+      const lines = ['🧠 *Recent Memories*', ''];
+      for (const m of recent) {
+        const ago = Math.round((Date.now() - m.timestamp) / 60000);
+        const timeLabel = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
+        const icon = { interaction: '💬', discovery: '🔍', thought: '💭', creation: '🎨' }[m.type] || '•';
+        lines.push(`${icon} ${m.summary} _(${timeLabel})_`);
+      }
+      lines.push('', '_Use `/memories about <topic>` to search._');
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
+    // ── /evolution command ──────────────────────────────────────────
+    if (text === '/evolution' || text.startsWith('/evolution ')) {
+      logger.info(`[Bot] /evolution command from ${username} (${userId}) in chat ${chatId}`);
+      const args = text.slice('/evolution'.length).trim();
+
+      if (!evolutionTracker) {
+        await bot.sendMessage(chatId, 'Evolution system is not available.');
+        return;
+      }
+
+      if (args === 'history') {
+        const proposals = evolutionTracker.getRecentProposals(10);
+        if (proposals.length === 0) {
+          await bot.sendMessage(chatId, 'No evolution proposals yet.');
+          return;
+        }
+        const lines = ['*Evolution History*', ''];
+        for (const p of proposals.reverse()) {
+          const statusIcon = { research: '🔬', planned: '📋', coding: '💻', pr_open: '🔄', merged: '✅', rejected: '❌', failed: '💥' }[p.status] || '•';
+          const age = Math.round((Date.now() - p.createdAt) / 3600_000);
+          const ageLabel = age < 24 ? `${age}h ago` : `${Math.round(age / 24)}d ago`;
+          lines.push(`${statusIcon} \`${p.id}\` — ${p.status} (${ageLabel})`);
+          lines.push(`  ${(p.triggerContext || '').slice(0, 100)}`);
+          if (p.prUrl) lines.push(`  PR: ${p.prUrl}`);
+          lines.push('');
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      if (args === 'lessons') {
+        const lessons = evolutionTracker.getRecentLessons(15);
+        if (lessons.length === 0) {
+          await bot.sendMessage(chatId, 'No evolution lessons learned yet.');
+          return;
+        }
+        const lines = ['*Evolution Lessons*', ''];
+        for (const l of lessons.reverse()) {
+          lines.push(`• [${l.category}] ${l.lesson}`);
+          if (l.fromProposal) lines.push(`  _from ${l.fromProposal}_`);
+          lines.push('');
+        }
+        await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+        return;
+      }
+
+      if (args === 'trigger') {
+        if (!lifeEngine) {
+          await bot.sendMessage(chatId, 'Life engine is not available.');
+          return;
+        }
+        await bot.sendMessage(chatId, '⚡ Triggering evolution cycle...');
+        lifeEngine.triggerNow('self_code').catch(err => {
+          logger.error(`[Bot] Evolution trigger failed: ${err.message}`);
+        });
+        return;
+      }
+
+      if (args === 'scan') {
+        if (!codebaseKnowledge) {
+          await bot.sendMessage(chatId, 'Codebase knowledge is not available.');
+          return;
+        }
+        await bot.sendMessage(chatId, '🔍 Scanning codebase...');
+        codebaseKnowledge.scanChanged().then(count => {
+          bot.sendMessage(chatId, `✅ Scanned ${count} changed files.`).catch(() => {});
+        }).catch(err => {
+          bot.sendMessage(chatId, `Failed: ${err.message}`).catch(() => {});
+        });
+        return;
+      }
+
+      // Default: show status
+      const active = evolutionTracker.getActiveProposal();
+      const stats = evolutionTracker.getStats();
+      const openPRs = evolutionTracker.getPRsToCheck();
+
+      const lines = [
+        '🧬 *Self-Evolution*',
+        '',
+        `*Stats:* ${stats.totalProposals} total | ${stats.merged} merged | ${stats.rejected} rejected | ${stats.failed} failed`,
+        `*Success rate:* ${stats.successRate}%`,
+        `*Open PRs:* ${openPRs.length}`,
+      ];
+
+      if (active) {
+        const statusIcon = { research: '🔬', planned: '📋', coding: '💻', pr_open: '🔄' }[active.status] || '•';
+        lines.push('');
+        lines.push(`*Active proposal:* ${statusIcon} \`${active.id}\` — ${active.status}`);
+        lines.push(`  ${(active.triggerContext || '').slice(0, 120)}`);
+        if (active.prUrl) lines.push(`  PR: ${active.prUrl}`);
+      } else {
+        lines.push('', '_No active proposal_');
+      }
+
+      lines.push(
+        '',
+        '_Commands:_',
+        '`/evolution history` — Recent proposals',
+        '`/evolution lessons` — Learned lessons',
+        '`/evolution trigger` — Trigger evolution now',
+        '`/evolution scan` — Scan codebase',
+      );
+
+      await bot.sendMessage(chatId, lines.join('\n'), { parse_mode: 'Markdown' });
+      return;
+    }
+
     if (text === '/help') {
       const activeSkill = agent.getActiveSkill(chatId);
       const skillLine = activeSkill
@@ -1117,6 +1412,10 @@ export function startBot(config, agent, conversationManager, jobManager, automat
         '/jobs — List running and recent jobs',
         '/cancel — Cancel running job(s)',
         '/auto — Manage recurring automations',
+        '/life — Inner life engine status & control',
+        '/journal — View today\'s journal or a past date',
+        '/memories — View recent memories or search',
+        '/evolution — Self-evolution status, history, lessons',
         '/context — Show all models, auth, and context info',
         '/clean — Clear conversation and start fresh',
         '/history — Show message count in memory',
@@ -1293,12 +1592,12 @@ export function startBot(config, agent, conversationManager, jobManager, automat
                 });
                 return edited.message_id;
               } catch {
-                return opts.editMessageId;
+                // Edit failed — fall through to send new message
               }
             }
           }
 
-          // Send new message(s)
+          // Send new message(s) — also reached when edit fails
           const parts = splitMessage(update);
           let lastMsgId = null;
           for (const part of parts) {