ai-control-center 1.15.2

package/lib/roleplay/pm-agent.js

@@ -0,0 +1,513 @@
+import { getRoleplayConfig } from './roleplay-config.js';
+import { postMessage, postAction, askCEO, getRoomHistory, onCEOMessage, dispatchCEOMessage } from './room.js';
+import { startMonitor, stopMonitor, getProviderStatus, getStageHealth, getAvailableProviders, suggestRecoveryAction } from './health-monitor.js';
+import { openThread, postToThread, escalateThread } from './discussion-threads.js';
+
+// Lazy-loaded askAI — avoid circular import with action-runner
+let _askAI = null;
+async function getAskAI() {
+  if (!_askAI) {
+    const mod = await import('../shared/action-runner.js');
+    _askAI = mod.askAI;
+  }
+  return _askAI;
+}
+
+let _bus = null;
+let _room = null;
+let _running = false;
+let _progressTimer = null;
+let _recoveryWatcher = null;
+
+const PM_SYSTEM_PROMPT = `You are the PM (Project Manager) of a software development team. You communicate in a group chat with your boss (the CEO/user) and your team (Architect, Coder, Reviewer, Deployer).
+
+Rules:
+- Keep messages SHORT (1-3 sentences max)
+- Be professional and informative
+- Use emoji sparingly (max 1-2 per message)
+- Never show raw error logs — summarize issues clearly
+- Reference team members with @Name format
+- Stay positive and solution-focused
+`;
+
+// PM internal state — tracked per feature
+const pmState = {
+  featureId: null,
+  retryCount: {},
+  providerSwitches: {},
+  reviewCycles: 0,
+  totalErrors: 0,
+  lastErrorTime: null,
+  consecutiveErrors: 0,
+  stallRecoveries: 0,
+  providerRecoveryWatcher: null,
+  stageStartTimes: {},
+  currentStage: null,
+  lastProgressUpdate: 0,
+  lastSuggestionTime: 0,
+
+  MAX_RETRIES_PER_STAGE: 5,
+  MAX_REVIEW_CYCLES: 3,
+  MAX_CONSECUTIVE_ERRORS: 8,
+  MAX_STALL_RECOVERIES: 3,
+  PROVIDER_RECOVERY_INTERVAL: 60_000,
+  ALL_DOWN_RETRY_INTERVAL: 300_000,
+  ALL_DOWN_MAX_WAIT: 1_800_000,
+};
+
+function resetPMState(featureId) {
+  pmState.featureId = featureId;
+  pmState.retryCount = {};
+  pmState.providerSwitches = {};
+  pmState.reviewCycles = 0;
+  pmState.totalErrors = 0;
+  pmState.lastErrorTime = null;
+  pmState.consecutiveErrors = 0;
+  pmState.stallRecoveries = 0;
+  pmState.stageStartTimes = {};
+  pmState.currentStage = null;
+  pmState.lastProgressUpdate = 0;
+}
+
+// Generate a PM message using a simple template approach
+// (In production this would call runAI with haiku, but we keep it deterministic for testability)
+function generatePMMessage(situation, context = {}) {
+  const messages = {
+    feature_received: (ctx) => `Got it! Analyzing "${ctx.feature?.slice(0, 60) || 'your request'}"...`,
+    writing_spec: () => `Writing the spec now. Give me ~2 minutes.`,
+    spec_done: (ctx) => `Spec done! ${ctx.lines ? `(${ctx.lines} lines) ` : ''}@Architect, please design this.`,
+    arch_done: (ctx) => `Architecture ready${ctx.summary ? `: ${ctx.summary}` : ''}. @Coder, start implementing.`,
+    impl_done: () => `Implementation complete! @Reviewer, please review.`,
+    review_found_issues: (ctx) => `Review found ${ctx.count || 'some'} issue(s). @Coder, please fix: ${ctx.summary || 'see review output'}.`,
+    review_approved: () => `Code approved! ✅ Ready to deploy, boss.`,
+    still_working: (ctx) => `${ctx.role || 'Team'} is still working... ${ctx.stage ? `(${ctx.stage} stage)` : ''} Hang tight.`,
+    switching_provider: (ctx) => `Switching from ${ctx.from || 'current provider'} to ${ctx.to || 'backup'}. Back on track shortly.`,
+    provider_recovered: (ctx) => `${ctx.provider || 'Provider'} is back online. Resuming pipeline.`,
+    all_providers_down: () => `All AI providers are currently unavailable. I'll keep retrying every 5 minutes.`,
+    retrying: (ctx) => `Retry ${ctx.attempt || 1}: trying again...`,
+    stage_complete: (ctx) => `${ctx.stage || 'Stage'} complete. Moving on.`,
+    error_handled: (ctx) => `Had an issue: ${ctx.summary || 'something went wrong'}. Switched to ${ctx.action || 'backup'}. Continuing.`,
+    review_loop_broken: () => `This is review cycle 3 — remaining issues are minor. Auto-approving and noting for follow-up.`,
+    deploy_ask: () => `Feature ready! Deploy now? [Yes/No]`,
+    deploy_done: (ctx) => `Deployed! 🚀 Summary: ${ctx.duration ? `⏱ ${ctx.duration}` : ''} ${ctx.cost ? `💰 ${ctx.cost}` : ''}`,
+    pipeline_paused: () => `Pipeline paused — all providers down. I'll auto-resume when any provider recovers.`,
+    absent_decision: (ctx) => `I went ahead with ${ctx.decision || 'the best option'} since you were away. Let me know if you want to change it.`,
+  };
+
+  const fn = messages[situation];
+  if (fn) return fn(context);
+  return `Update: ${situation}`;
+}
+
+export function startPMAgent(bus, room) {
+  if (_running) return;
+  _bus = bus;
+  _room = room;
+  _running = true;
+
+  const config = getRoleplayConfig();
+
+  // Start health monitor
+  startMonitor(bus, { checkInterval: 30_000 });
+
+  // Listen to CEO messages
+  onCEOMessage((message, ctx) => {
+    handleCEOMessage(message, ctx).catch(() => {});
+  });
+
+  // Listen to pipeline events
+  bus.on('pipeline-event', ({ event, data }) => {
+    try {
+      handlePipelineEvent(event, data);
+    } catch { /* non-fatal */ }
+  });
+
+  // Progress update timer
+  if (config.progressUpdates) {
+    _progressTimer = setInterval(() => {
+      checkProgress();
+    }, Math.min(config.progressInterval || 60_000, 120_000));
+  }
+}
+
+export function stopPMAgent() {
+  _running = false;
+  if (_progressTimer) { clearInterval(_progressTimer); _progressTimer = null; }
+  if (_recoveryWatcher) { clearInterval(_recoveryWatcher); _recoveryWatcher = null; }
+  stopMonitor();
+}
+
+// Track pending feature from AI response so text confirmations ("ok", "yes") work
+let _pendingFeature = null;
+
+async function handleCEOMessage(message, ctx) {
+  if (!_running) return;
+
+  const lower = message.toLowerCase().trim();
+
+  // ── /assign command ──────────────────────────────────────────────────────
+  if (lower.startsWith('/assign') || lower.startsWith('assign ')) {
+    const parts = message.replace(/^\/?(assign)\s*/i, '').trim().split(/\s+/);
+    const url   = parts[0];
+    const goal  = parts.slice(1).join(' ');
+
+    if (!url || !goal) {
+      postMessage('pm', 'Usage: /assign <url> <project goal>\nExample: /assign https://myapp.com Build a complete e-commerce store with payment');
+      return;
+    }
+
+    postMessage('pm', `Assigning project: ${url}\nGoal: ${goal}\nStarting setup...`);
+
+    try {
+      const { assignProjectAction } = await import('../actions/assign-project.js');
+      await assignProjectAction({ url, goal });
+    } catch (err) {
+      postMessage('pm', `Assignment failed: ${err.message.slice(0, 150)}`);
+    }
+    return;
+  }
+
+  // ── /suggest command ──────────────────────────────────────────────────────
+  if (lower === '/suggest' || lower === 'suggest') {
+    postMessage('pm', 'Running suggestion analysis...');
+    try {
+      const { runSuggestionAgent } = await import('../agents/suggestion-agent.js');
+      const result = await runSuggestionAgent();
+      if (result.success && result.suggestions?.length > 0) {
+        const titles = result.suggestions.map((s, i) => `${i + 1}. "${s.title}"`).join('\n');
+        postMessage('pm', `Feature suggestions:\n${titles}`);
+      } else if (result.skipped) {
+        postMessage('pm', 'Suggestion agent is disabled. Enable in aicc.config.js: suggestion.enabled = true');
+      } else {
+        postMessage('pm', 'No suggestions generated.');
+      }
+    } catch (err) {
+      postMessage('pm', `Suggestion failed: ${err.message.slice(0, 100)}`);
+    }
+    return;
+  }
+
+  // Only intercept explicit slash commands — everything else goes to AI
+  if (lower.startsWith('/feature') || lower.startsWith('feature ')) {
+    const desc = message.replace(/^\/?feature\s*/i, '').trim();
+    postMessage('pm', generatePMMessage('feature_received', { feature: desc }));
+    setTimeout(() => {
+      postMessage('pm', generatePMMessage('writing_spec'));
+    }, 500);
+    resetPMState(desc.slice(0, 40));
+    return;
+  }
+
+  // ── Text confirmation for pending feature ──────────────────────────────────
+  // When PM showed create_feature buttons but user replied with text instead of clicking
+  const confirmPatterns = /^(ok|yes|yep|yea|yeah|sure|go|go ahead|do it|let's go|lgtm|confirm|làm đi|tạo đi|được|ừ|ờ|oke|okie|vâng|đồng ý|bắt đầu|start|create|duyệt)$/i;
+  if (_pendingFeature && confirmPatterns.test(lower)) {
+    const { description, type } = _pendingFeature;
+    _pendingFeature = null;
+    postMessage('pm', `Starting ${type === 'bug' ? 'bug fix' : 'feature'} pipeline (auto mode)...`);
+    resetPMState(description.slice(0, 40));
+    try {
+      const actions = await import('../shared/action-runner.js');
+      const result = await actions.runNewFeature(description, 'auto', type);
+      if (!result.success) {
+        postMessage('pm', `Failed to start pipeline: ${result.error}`);
+      }
+    } catch (err) {
+      postMessage('pm', `Pipeline error: ${err.message?.slice(0, 100)}`);
+    }
+    return;
+  }
+
+  // All other messages → AI with conversation history for context
+  try {
+    const askAI = await getAskAI();
+    // Build conversation context from room history so AI remembers previous messages
+    const history = getRoomHistory(20);
+    const contextLines = history
+      .filter(h => h.type === 'text' || h.type === 'question')
+      .map(h => `[${h.role === 'ceo' ? 'User' : h.role.toUpperCase()}]: ${h.message}`)
+      .join('\n');
+    const conversationContext = contextLines
+      ? `## Recent Conversation\n${contextLines}`
+      : '';
+
+    const result = await askAI(message, conversationContext);
+    // askAI returns a string on success, or { error: "..." } on failure
+    if (typeof result === 'string' && result.trim()) {
+      // Parse action JSON from AI response (same pattern as telegram/commands.js)
+      const stripped = result.replace(/```(?:json)?\s*/gi, '').replace(/```/g, '');
+      const actionMatch = stripped.match(/\{"_?action"\s*:\s*"[^"]+".+?\}(?=\s|$)/s);
+      if (actionMatch) {
+        let action;
+        try {
+          action = JSON.parse(actionMatch[0]);
+        } catch {
+          // Try balanced-brace extraction if simple regex match isn't valid JSON
+          const start = stripped.indexOf('{"_action"') >= 0 ? stripped.indexOf('{"_action"') : stripped.indexOf('{"action"');
+          if (start >= 0) {
+            let depth = 0, end = start;
+            for (let i = start; i < stripped.length; i++) {
+              if (stripped[i] === '{') depth++;
+              else if (stripped[i] === '}') { depth--; if (depth === 0) { end = i + 1; break; } }
+            }
+            try { action = JSON.parse(stripped.slice(start, end)); } catch { /* give up */ }
+          }
+        }
+        if (action) {
+          const explanation = stripped.slice(0, actionMatch.index).trim();
+          const actionName = action._action || action.action;
+
+          if (actionName === 'create_feature' || actionName === 'createfeature') {
+            const desc = (action.description || message).trim();
+            const type = action.type === 'bug' ? 'bug' : 'feature';
+            const label = type === 'bug' ? 'Bug Fix' : 'Feature';
+            const encodedDesc = encodeURIComponent(desc.slice(0, 50));
+            // Save pending feature so text confirmation ("ok", "yes") works
+            _pendingFeature = { description: desc, type };
+            if (explanation) postMessage('pm', explanation);
+            // Show confirmation with inline buttons (same callback format as keyboards.js)
+            postMessage('pm', `${label}: "${desc.slice(0, 120)}"\n\nWant me to set this up?`, {
+              buttons: [
+                { text: type === 'bug' ? '🐛 Yes, create bug fix' : '✨ Yes, create feature', callback: `confirm:${type}:yes:${encodedDesc}` },
+                { text: '✏️ Let me refine it', callback: `confirm:${type}:edit:${encodedDesc}` },
+                { text: '💬 Just discussing', callback: 'confirm:no' },
+              ],
+            });
+            return;
+          }
+
+          // Pipeline execution actions
+          if (_bus && actionName) {
+            if (explanation) postMessage('pm', explanation);
+            _bus.emitEvent('room:pipeline_action', { action: actionName, data: action });
+            return;
+          }
+        }
+      }
+
+      // Clean response: strip any action JSON blobs before displaying
+      const cleanResult = result
+        .replace(/```(?:json)?\s*\{[^}]*"_?action"[^}]*\}\s*```/g, '')
+        .replace(/\{"_?action"\s*:[^}]+\}/g, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+      if (cleanResult) {
+        postMessage('pm', cleanResult);
+      } else {
+        postMessage('pm', `Noted. I'll keep you posted on progress.`);
+      }
+    } else if (result && typeof result === 'object' && result.error) {
+      postMessage('pm', `Having trouble reaching AI providers right now. ${result.error.slice(0, 100)}`);
+    } else {
+      postMessage('pm', `Noted. I'll keep you posted on progress.`);
+    }
+  } catch (err) {
+    postMessage('pm', `AI is temporarily unavailable. I'll keep you posted on progress.`);
+  }
+}
+
+function handlePipelineEvent(event, data) {
+  if (!_running) return;
+
+  switch (event) {
+    case 'stage_start':
+      pmState.currentStage = data.stage;
+      pmState.stageStartTimes[data.stage] = Date.now();
+      // Don't duplicate — action-runner.js already sends the stage_start notification
+      break;
+
+    case 'stage_complete':
+      pmState.consecutiveErrors = 0;
+      // Don't duplicate stage completion messages — action-runner.js notify() already
+      // sends detailed messages for every stage. PM agent only adds value for errors
+      // and provider switching, which are handled in 'stage_error' below.
+      if (data.stage === 'review' || data.stage === 'review_complete') {
+        const hasIssues = data.verdict === 'REJECTED';
+        if (hasIssues) {
+          pmState.reviewCycles++;
+          if (pmState.reviewCycles >= pmState.MAX_REVIEW_CYCLES) {
+            postMessage('pm', generatePMMessage('review_loop_broken'));
+          }
+          // Don't send review_found_issues — action-runner already sends detailed review
+        }
+        // Don't send review_approved or deploy_ask — action-runner sends approve/deploy flow
+      }
+      break;
+
+    case 'stage_error':
+      handleStageError(data.stage, data.error, data);
+      break;
+
+    case 'pipeline_stalled':
+      handleStall(data.stage, data.minutesElapsed * 60_000);
+      break;
+
+    case 'pipeline_stall_recovery':
+      postMessage('pm', `Stage ${data.stage || ''} was stuck. Restarting...`);
+      break;
+
+    case 'feature_created':
+      resetPMState(data.feature || data.description);
+      break;
+
+    case 'feature_reset':
+    case 'feature_abandoned':
+      // Clear PM state to stop stale heartbeat/progress messages after /reset
+      resetPMState(null);
+      break;
+
+    case 'health_status':
+      checkProviderRecovery(data.providers);
+      break;
+
+    case 'qa_bugfix_exhausted': {
+      try {
+        const threadId = openThread(
+          'bug_found',
+          `QA bugs unresolved after ${data.cycles} fix attempts`,
+          data,
+          'pm'
+        );
+        postToThread(threadId, 'pm', `Tried ${data.cycles} times to fix ${data.remainingFails} failing page(s). Need your input.`);
+        escalateThread(threadId, 'Automatic bug fix loop exhausted');
+      } catch { /* threads module not available */ }
+      break;
+    }
+  }
+}
+
+function handleStageError(stage, error, data = {}) {
+  pmState.totalErrors++;
+  pmState.consecutiveErrors++;
+  pmState.retryCount[stage] = (pmState.retryCount[stage] || 0) + 1;
+
+  if (pmState.consecutiveErrors >= pmState.MAX_CONSECUTIVE_ERRORS) {
+    postMessage('pm', generatePMMessage('pipeline_paused'), { type: 'error' });
+    startRecoveryWatcher();
+    return;
+  }
+
+  const action = suggestRecoveryAction(stage, error);
+  const available = getAvailableProviders(stage);
+
+  if (action === 'switch_provider' && available.length > 0) {
+    const to = available[0];
+    postMessage('pm', generatePMMessage('switching_provider', {
+      from: data.model_used || 'current provider',
+      to,
+    }));
+    if (_bus) {
+      _bus.emitEvent('room:agent_switch', { stage, from: data.model_used, to });
+    }
+  } else if (action === 'wait_and_retry') {
+    postMessage('pm', generatePMMessage('retrying', { attempt: pmState.retryCount[stage] }));
+  } else if (action === 'escalate_ceo') {
+    postMessage('pm', generatePMMessage('all_providers_down'), { type: 'error' });
+    startRecoveryWatcher();
+  } else {
+    postMessage('pm', generatePMMessage('error_handled', {
+      summary: String(error || 'unknown error').slice(0, 80),
+      action: action.replace(/_/g, ' '),
+    }));
+  }
+}
+
+function handleStall(stage, durationMs) {
+  pmState.stallRecoveries++;
+  const health = getStageHealth(stage, pmState.stageStartTimes[stage]);
+
+  if (health.status === 'slow') {
+    // Only post if we haven't posted recently
+    const now = Date.now();
+    if (now - pmState.lastProgressUpdate > 180_000) {
+      pmState.lastProgressUpdate = now;
+      postMessage('pm', generatePMMessage('still_working', { stage }));
+    }
+  } else if (health.status === 'stalled') {
+    postMessage('pm', `Stage ${stage} appears stuck. Auto-recovering...`, { type: 'status' });
+  }
+}
+
+function checkProgress() {
+  if (!_running) return;
+
+  // ── Active stage progress ──────────────────────────────────────────────────
+  if (pmState.currentStage) {
+    const stageStart = pmState.stageStartTimes[pmState.currentStage];
+    if (stageStart) {
+      const health = getStageHealth(pmState.currentStage, stageStart);
+      const now = Date.now();
+
+      if (health.status === 'slow' && now - pmState.lastProgressUpdate > (getRoleplayConfig().progressInterval || 180_000)) {
+        pmState.lastProgressUpdate = now;
+        postMessage('pm', generatePMMessage('still_working', { role: pmState.currentStage, stage: pmState.currentStage }));
+      }
+    }
+    return;
+  }
+
+  // ── Idle — run suggestion agent if enabled ────────────────────────────────
+  const config = getRoleplayConfig();
+  const idleMs = (config.suggestion?.idleAfterMinutes || 60) * 60 * 1000;
+  const now = Date.now();
+
+  if (
+    config.suggestion?.enabled !== false &&
+    (now - pmState.lastSuggestionTime) > idleMs
+  ) {
+    pmState.lastSuggestionTime = now;
+    import('../agents/suggestion-agent.js')
+      .then(mod => mod.runSuggestionAgent())
+      .then(result => {
+        if (result.success && result.suggestions?.length > 0) {
+          const titles = result.suggestions.map(s => `"${s.title}"`).join(', ');
+          postMessage('pm', `Idle analysis complete. Suggestions: ${titles}. Type /suggest to review.`);
+        }
+      })
+      .catch(() => {});
+  }
+}
+
+function checkProviderRecovery(providers) {
+  if (!_recoveryWatcher) return; // only relevant when in recovery mode
+  const anyHealthy = Object.values(providers).some(s => s === 'healthy' || s === 'degraded');
+  if (anyHealthy) {
+    clearInterval(_recoveryWatcher);
+    _recoveryWatcher = null;
+    pmState.consecutiveErrors = 0;
+    postMessage('pm', generatePMMessage('provider_recovered', {
+      provider: Object.entries(providers).find(([,s]) => s !== 'down')?.[0] || 'provider',
+    }));
+  }
+}
+
+function startRecoveryWatcher() {
+  if (_recoveryWatcher) return;
+  let retries = 0;
+  const maxRetries = Math.ceil(pmState.ALL_DOWN_MAX_WAIT / pmState.ALL_DOWN_RETRY_INTERVAL);
+
+  _recoveryWatcher = setInterval(() => {
+    retries++;
+    const providers = getProviderStatus();
+    const anyHealthy = Object.values(providers).some(s => s !== 'down');
+
+    if (anyHealthy) {
+      clearInterval(_recoveryWatcher);
+      _recoveryWatcher = null;
+      pmState.consecutiveErrors = 0;
+      postMessage('pm', generatePMMessage('provider_recovered', {
+        provider: Object.entries(providers).find(([,s]) => s !== 'down')?.[0] || 'provider',
+      }));
+    } else if (retries >= maxRetries) {
+      clearInterval(_recoveryWatcher);
+      _recoveryWatcher = null;
+      // After 30 min, just stay paused — no CEO escalation for provider failures
+      postMessage('pm', `Pipeline paused for 30+ minutes due to provider outage. Will auto-resume when providers recover.`);
+    } else {
+      postMessage('pm', `Still down. Retry ${retries}/${maxRetries}.`);
+    }
+  }, pmState.ALL_DOWN_RETRY_INTERVAL);
+}
+
+// Expose for testing
+export { handleCEOMessage, handlePipelineEvent, handleStageError, pmState, resetPMState };

package/lib/roleplay/roleplay-config.js

@@ -0,0 +1,25 @@
+import { getConfig } from '../config.js';
+
+export const ROLEPLAY_DEFAULTS = {
+  enabled: true,
+  verbosity: 'normal',
+  pmPersonality: 'professional',
+  agentChat: true,
+  progressUpdates: true,
+  progressInterval: 60000,
+  maxReviewCycles: 3,
+  autoDeployOnApproval: false,
+};
+
+export function getRoleplayConfig() {
+  try {
+    const config = getConfig();
+    return { ...ROLEPLAY_DEFAULTS, ...(config.roleplay || {}) };
+  } catch {
+    return { ...ROLEPLAY_DEFAULTS };
+  }
+}
+
+export function isRoleplayEnabled() {
+  return getRoleplayConfig().enabled === true;
+}