ai-control-center 1.15.2

package/lib/telegram/keyboards.js

@@ -0,0 +1,113 @@
+/**
+ * Inline keyboard helpers for Telegram bot.
+ */
+import { InlineKeyboard } from 'grammy';
+
+/** Main menu — mirrors all terminal CLI options */
+export function mainMenuKeyboard() {
+  return new InlineKeyboard()
+    .text('New Feature', 'menu:feature').text('Fix a Bug', 'menu:bug').row()
+    .text('Review Code', 'menu:review').text('Pipeline Status', 'menu:status').row()
+    .text('View Docs', 'menu:docs').text('Debug / Logs', 'menu:logs').row()
+    .text('Approve', 'menu:approve').text('Reject', 'menu:reject').row()
+    .text('Deploy', 'menu:deploy').text('Toggle Auto-Pilot', 'menu:autopilot').row()
+    .text('Health Check', 'menu:health').text('Reset / Abandon', 'menu:reset').row()
+    .text('Ask AI', 'menu:ask').text('AI Mode', 'menu:aimode');
+}
+
+/** Deploy test level selection keyboard */
+export function deployKeyboard() {
+  return new InlineKeyboard()
+    .text('No Tests (fast)', 'deploy:NoTestRun')
+    .text('Run Tests', 'deploy:RunLocalTests');
+}
+
+/** Post-review action keyboard */
+export function reviewActionsKeyboard() {
+  return new InlineKeyboard()
+    .text('Approve', 'action:approve')
+    .text('Reject', 'action:reject');
+}
+
+/** Feature mode selection */
+export function featureModeKeyboard(type = 'feature') {
+  return new InlineKeyboard()
+    .text('Manual', `fmode:${type}:manual`)
+    .text('Auto-Pilot', `fmode:${type}:auto`);
+}
+
+/** Document picker — shows available workflow documents */
+export function docsKeyboard(docs) {
+  const kb = new InlineKeyboard();
+  docs.forEach(({ label, key }, i) => {
+    kb.text(label, `doc:view:${key}:0`);
+    if (i % 2 === 1) kb.row();
+  });
+  if (docs.length % 2 !== 0) kb.row();
+  return kb;
+}
+
+/** Pagination keyboard for a document */
+export function docPageKeyboard(key, page, totalPages) {
+  const kb = new InlineKeyboard();
+  if (page > 0)              kb.text('⬅ Prev', `doc:view:${key}:${page - 1}`);
+  if (page < totalPages - 1) kb.text('Next ➡', `doc:view:${key}:${page + 1}`);
+  kb.row().text('📋 Back to Docs', 'doc:list');
+  return kb;
+}
+
+/** Log session picker */
+export function logsKeyboard(sessions) {
+  const kb = new InlineKeyboard();
+  sessions.forEach(({ label, key }, i) => {
+    kb.text(label, `log:view:${key}:0`);
+    if (i % 2 === 1) kb.row();
+  });
+  if (sessions.length % 2 !== 0) kb.row();
+  return kb;
+}
+
+/** Pagination keyboard for a log file */
+export function logPageKeyboard(key, page, totalPages) {
+  const kb = new InlineKeyboard();
+  if (page > 0)              kb.text('⬅ Prev', `log:view:${key}:${page - 1}`);
+  if (page < totalPages - 1) kb.text('Next ➡', `log:view:${key}:${page + 1}`);
+  kb.row().text('🗒 Back to Logs', 'log:list');
+  return kb;
+}
+
+/**
+ * AI confirmation keyboard — shown when AI detects intent (bug/feature/action)
+ * so the user can confirm with a tap instead of a second AI request.
+ * @param {'bug'|'feature'} type - The feature type detected
+ * @param {string} description - Short summary of what was detected
+ */
+export function confirmActionKeyboard(type = 'feature', description = '') {
+  const label = type === 'bug' ? '🐛 Yes, create bug fix' : '✨ Yes, create feature';
+  // Encode description into callback data (trimmed to 50 chars for Telegram limit)
+  const desc = encodeURIComponent((description || '').slice(0, 50));
+  return new InlineKeyboard()
+    .text(label, `confirm:${type}:yes:${desc}`).row()
+    .text('✏️ Let me refine it', `confirm:${type}:edit:${desc}`).row()
+    .text('💬 Just discussing', 'confirm:no');
+}
+
+/**
+ * Pipeline action confirmation keyboard — shown when AI recognises a
+ * pipeline command (fix/review/approve/deploy) so user can one-tap it.
+ * @param {string} action - The pipeline action (e.g. run_fix, run_review)
+ */
+export function confirmPipelineKeyboard(action) {
+  const labels = {
+    run_fix:            '🔧 Yes, fix it',
+    run_review:         '🔍 Yes, review',
+    run_fix_and_review: '🔧🔍 Yes, fix + review',
+    run_approve:        '✅ Yes, approve',
+    run_deploy:         '🚀 Yes, deploy',
+    run_implement:      '⚡ Yes, implement'
+  };
+  const label = labels[action] || `✅ Confirm ${action}`;
+  return new InlineKeyboard()
+    .text(label, `pipeconfirm:${action}:yes`).row()
+    .text('💬 No, just chatting', 'pipeconfirm:no');
+}

package/lib/telegram/notifications.js

@@ -0,0 +1,247 @@
+/**
+ * Push notifications — sends Telegram messages on pipeline events.
+ *
+ * Requires TELEGRAM_CHAT_ID to be set (auto-prefixed via env()).
+ */
+
+// Debounce: don't spam on rapid status.json writes
+let lastNotifiedStage = null;
+let lastNotifyTime = 0;
+const DEBOUNCE_MS = 3000;
+
+export function setupNotifications(bot, bus, chatId) {
+  if (!chatId) return;
+
+  // Typing indicator management — fires while AI is working
+  let typingInterval = null;
+
+  function startTyping() {
+    clearInterval(typingInterval);
+    typingInterval = setInterval(async () => {
+      try { await bot.api.sendChatAction(chatId, 'typing'); } catch { /* ignore */ }
+    }, 4000); // Telegram typing action lasts 5s, refresh every 4s
+  }
+
+  function stopTyping() {
+    clearInterval(typingInterval);
+    typingInterval = null;
+  }
+
+  // Pipeline events (explicit actions)
+  bus.on('pipeline-event', async ({ event, data }) => {
+    // Room events are handled by the dedicated handler below — skip here
+    if (event.startsWith('room:')) return;
+
+    // Start/stop typing indicator based on stage lifecycle
+    if (event === 'stage_start') {
+      startTyping();
+    } else if (event === 'stage_complete' || event === 'stage_error' || event === 'stage_fallback') {
+      stopTyping();
+    }
+
+    // Opus confirmation request — show inline keyboard
+    if (event === 'opus_confirm_request') {
+      stopTyping();
+      const { InlineKeyboard } = await import('grammy');
+      const kb = new InlineKeyboard()
+        .text('✅ Use Opus 4.6 (premium)', `opus:confirm:${data.featureId}`)
+        .text('⚡ Use Sonnet 4.6 (free)', `opus:decline:${data.featureId}`);
+      await safeSend(bot, chatId, data.message, { parse_mode: 'HTML', reply_markup: kb });
+      return;
+    }
+
+    // Loop limit reached — ask user to continue or stop
+    if (event === 'loop_confirm_request') {
+      stopTyping();
+      const { InlineKeyboard } = await import('grammy');
+      const kb = new InlineKeyboard()
+        .text('🔁 Continue fixing', `loop:continue:${data.featureId}`)
+        .text('🛑 Stop auto-pilot', `loop:stop:${data.featureId}`);
+      await safeSend(bot, chatId, data.message, { parse_mode: 'HTML', reply_markup: kb });
+      return;
+    }
+
+    // Auto-reset after deployment — inform user pipeline is ready for next task
+    if (event === 'auto_reset') {
+      stopTyping();
+      await safeSend(bot, chatId,
+        data.message || `🔄 Pipeline auto-reset to idle. Ready for the next task.`,
+        { parse_mode: 'HTML' }
+      );
+      return;
+    }
+
+    // Pipeline stall warning — fires if a stage hasn't progressed in 5+ minutes
+    if (event === 'pipeline_stalled') {
+      stopTyping();
+      await safeSend(bot, chatId,
+        data.message || `⚠️ Pipeline appears stalled at stage <b>${data.stage}</b> (${data.minutesElapsed || '?'} min elapsed).\nUse /status to check.`,
+        { parse_mode: 'HTML' }
+      );
+      return;
+    }
+
+    // Pipeline stall auto-recovery — fires after consecutive stall detections
+    if (event === 'pipeline_stall_recovery') {
+      stopTyping();
+      await safeSend(bot, chatId,
+        data.message || `🔄 Pipeline stalled for 10min on <code>${data.stage}</code>. Auto-retrying...`,
+        { parse_mode: 'HTML' }
+      );
+      // Trigger the actual recovery
+      try {
+        const actions = await import('../shared/action-runner.js');
+        actions.autoResumePipeline();
+      } catch { /* non-fatal */ }
+      return;
+    }
+
+    // Long-idle heartbeat — periodic status update so user knows bot is alive
+    if (event === 'idle_heartbeat') {
+      await safeSend(bot, chatId, data.message || `📋 Bot is online and idle.`, { parse_mode: 'HTML' });
+      return;
+    }
+
+    // Use explicit message field if provided, otherwise look up in table
+    let msg = data.message || null;
+
+    if (!msg) {
+      // Only generate messages for events NOT already covered by action-runner notify().
+      // feature_approved, review_complete, deploy_success are already sent via notify()
+      // in the auto-pipeline flow, so skip them here to avoid duplicates.
+      const messages = {
+        feature_created:  `🚀 New feature started: ${data.description?.slice(0, 80) || data.feature}`,
+        feature_rejected: `❌ Feature rejected: ${data.reason?.slice(0, 100) || 'no reason'}`,
+        deploy_failed:    `💥 Deploy failed: ${data.error?.slice(0, 200) || 'unknown error'}`,
+        tasks_ready:      `✅ Tasks ready — Coder is ready to implement.`,
+      };
+      msg = messages[event] || null;
+    }
+
+    if (msg) {
+      // Attach context-driven action buttons where helpful
+      const { InlineKeyboard } = await import('grammy');
+      let kb = null;
+
+      if (event === 'qa_report_ready') {
+        if (data.summary?.failed > 0) {
+          kb = new InlineKeyboard().text('🔧 Fix bugs', 'action:fix').text('📋 QA Report', 'action:status');
+        } else {
+          kb = new InlineKeyboard().text('📋 Status', 'action:status');
+        }
+      } else if (event === 'bugfix_loop_complete') {
+        if (data.success) {
+          kb = new InlineKeyboard().text('📋 Status', 'action:status');
+        } else {
+          kb = new InlineKeyboard().text('🔧 Retry fix', 'action:fix').text('📋 QA Report', 'action:status');
+        }
+      } else if (event === 'feature_approved' || (msg && msg.includes('approved') && msg.includes('deploy'))) {
+        kb = new InlineKeyboard().text('🚀 Deploy now', 'action:deploy').text('📋 Status', 'action:status');
+      } else if (event === 'tasks_ready' || event === 'arch_complete') {
+        kb = new InlineKeyboard().text('⚡ Start Coder', 'action:approve').text('🔍 Review first', 'action:review').text('📋 Status', 'action:status');
+      } else if (event === 'review_complete') {
+        const verdict = data.verdict || '';
+        if (verdict === 'REJECTED' || (msg && msg.includes('REJECTED'))) {
+          kb = new InlineKeyboard().text('🔧 Auto-fix', 'action:fix').text('📄 View review', 'action:docs').text('📋 Status', 'action:status');
+        } else if (verdict === 'APPROVED' || (msg && msg.includes('APPROVED'))) {
+          kb = new InlineKeyboard().text('✅ Approve', 'action:approve').text('🚀 Deploy', 'action:deploy').text('📋 Status', 'action:status');
+        }
+      } else if (event === 'feature_rejected') {
+        // No keyboard here — the 'rejected' stage watcher already sends the Auto-fix button
+      } else if (event === 'deploy_failed') {
+        kb = new InlineKeyboard().text('🔄 Retry deploy', 'action:deploy').text('📋 Status', 'action:status');
+      }
+
+      await safeSend(bot, chatId, msg, kb ? { reply_markup: kb } : {});
+    }
+  });
+
+  // Room messages — forward agent chat to Telegram
+  bus.on('pipeline-event', async ({ event, data }) => {
+    if (event === 'room:message') {
+      const { formatForTelegram } = await import('../roleplay/agent-messenger.js');
+      const { isRoleplayEnabled } = await import('../roleplay/roleplay-config.js');
+      if (!isRoleplayEnabled()) return;
+      const formatted = formatForTelegram(data.role, data.message, data.type);
+      const opts = { parse_mode: 'Markdown' };
+      // Support inline buttons on room messages (e.g., feature confirmation from PM agent)
+      if (data.buttons && data.buttons.length) {
+        const { InlineKeyboard } = await import('grammy');
+        const kb = new InlineKeyboard();
+        for (const btn of data.buttons) {
+          kb.text(btn.text || btn.label, btn.callback || btn.action || btn.text).row();
+        }
+        opts.reply_markup = kb;
+      }
+      await safeSend(bot, chatId, formatted, opts);
+    } else if (event === 'room:ask_ceo') {
+      const { isRoleplayEnabled } = await import('../roleplay/roleplay-config.js');
+      if (!isRoleplayEnabled()) return;
+      const { formatForTelegram } = await import('../roleplay/agent-messenger.js');
+      const formatted = formatForTelegram('pm', data.message, 'question');
+      const opts = { parse_mode: 'Markdown' };
+      if (data.buttons && data.buttons.length) {
+        const { InlineKeyboard } = await import('grammy');
+        const kb = new InlineKeyboard();
+        for (const btn of data.buttons) {
+          kb.text(btn.label, btn.callback || btn.label);
+        }
+        opts.reply_markup = kb;
+      }
+      await safeSend(bot, chatId, formatted, opts);
+    }
+  });
+
+  // Status changes (from file watcher) — ONLY for manual mode transitions.
+  // In auto mode, action-runner.js notify() already sends detailed messages for
+  // every stage. The watcher only fires for stages triggered by manual commands
+  // (e.g., user clicks /review, /approve, /deploy directly).
+  bus.on('status', async ({ status, previousStage }) => {
+    // Only notify on meaningful stage transitions
+    if (!status.stage || status.stage === previousStage) return;
+    if (status.stage === lastNotifiedStage && Date.now() - lastNotifyTime < DEBOUNCE_MS) return;
+
+    // Skip stages that are covered by action-runner notify() in auto-pipeline flow.
+    // These stages generate their own Telegram messages via the heartbeat/stage events.
+    const autoHandledStages = new Set([
+      'spec', 'spec_complete', 'architecture', 'arch_complete',
+      'implementation', 'implementation_complete',
+      'review', 'review_complete', 'approved', 'deploying', 'deployed',
+      'rejected', 'fixing',
+    ]);
+    if (status.pipeline_mode === 'auto' && autoHandledStages.has(status.stage)) return;
+
+    lastNotifiedStage = status.stage;
+    lastNotifyTime = Date.now();
+
+    const { InlineKeyboard } = await import('grammy');
+
+    // Stage → {message, keyboard} — only for manual-mode transitions
+    const stageConfig = {
+      implementation_complete: { msg: '⚡ Coder implementation complete', kb: new InlineKeyboard().text('🔍 Review code', 'action:review').text('📋 Status', 'action:status') },
+      implementation_failed:   { msg: `⚠️ Coder implementation failed: ${status.error?.slice(0, 100) || 'unknown error'}`, kb: new InlineKeyboard().text('🔄 Retry', 'action:approve').text('📋 Status', 'action:status') },
+      review_complete:         { msg: `🔍 Review complete: ${status.latest_review || ''}`, kb: new InlineKeyboard().text('✅ Approve', 'action:approve').text('❌ Reject', 'action:reject').text('📄 Docs', 'action:docs') },
+      approved:                { msg: '✅ Feature approved — ready to deploy!', kb: new InlineKeyboard().text('🚀 Deploy now', 'action:deploy').text('📋 Status', 'action:status') },
+      rejected:                { msg: '❌ Feature rejected — fixes needed', kb: new InlineKeyboard().text('🔧 Auto-fix', 'action:fix').text('📄 View review', 'action:docs') },
+      deployed:                { msg: '🚀 Deployment complete! 🎉', kb: new InlineKeyboard().text('📋 Status', 'action:status').text('📄 Docs', 'action:docs') },
+    };
+
+    const cfg = stageConfig[status.stage];
+    if (cfg) {
+      const feature = status.current_feature ? `\n<code>${status.current_feature}</code>` : '';
+      await safeSend(bot, chatId, `${cfg.msg}${feature}`, cfg.kb ? { reply_markup: cfg.kb } : {});
+    }
+  });
+}
+
+async function safeSend(bot, chatId, text, options = {}) {
+  try {
+    await bot.api.sendMessage(chatId, text, { parse_mode: 'HTML', ...options });
+  } catch (err) {
+    // Make notification failures clearly visible — silent failures hide config problems
+    console.error(`  ⚠️  Telegram send FAILED to chat ${chatId}: ${err.message}`);
+    if (err.message?.includes('chat not found') || err.message?.includes('forbidden')) {
+      console.error(`  ⚠️  CHAT_ID ${chatId} is invalid. Check TELEGRAM_CHAT_ID in .env`);
+    }
+  }
+}