ai-control-center 1.15.2

package/lib/twitch/notifications.js

@@ -0,0 +1,63 @@
+/**
+ * Twitch push notifications — sends channel messages on pipeline events.
+ *
+ * Subscribes to the pipeline event bus and posts important status changes
+ * as chat messages in the configured Twitch channel.
+ */
+import { truncate } from './bot.js';
+
+// Debounce: avoid duplicate notifications on rapid status.json writes
+let lastNotifiedStage = null;
+let lastNotifyTime    = 0;
+const DEBOUNCE_MS     = 3000;
+
+export function setupNotifications(bot, bus) {
+  // Pipeline events (explicit actions triggered by aicc commands)
+  bus.on('pipeline-event', ({ event, data }) => {
+    let msg = data.message || null;
+
+    if (!msg) {
+      const messages = {
+        feature_created:  `New feature started: ${data.description?.slice(0, 60) || data.feature}`,
+        feature_approved: `Feature approved: ${data.feature}`,
+        feature_rejected: `Feature rejected: ${data.reason?.slice(0, 60) || 'no reason'}`,
+        deploy_success:   `Deploy successful!`,
+        deploy_failed:    `Deploy failed: ${data.error?.slice(0, 80) || 'unknown error'}`,
+        review_complete:  `Code review complete for ${data.feature}`,
+        tasks_ready:      `Tasks ready — ready to implement.`,
+      };
+      msg = messages[event] || null;
+    }
+
+    if (msg) {
+      bot.say(truncate(msg));
+    }
+  });
+
+  // Status changes (from file watcher on status.json)
+  bus.on('status', ({ status, previousStage }) => {
+    if (!status.stage || status.stage === previousStage) return;
+    if (status.stage === lastNotifiedStage && Date.now() - lastNotifyTime < DEBOUNCE_MS) return;
+
+    lastNotifiedStage = status.stage;
+    lastNotifyTime    = Date.now();
+
+    const feature = status.current_feature ? ` [${status.current_feature}]` : '';
+
+    const stageMessages = {
+      spec_complete:           `Spec complete${feature}`,
+      arch_complete:           `Architecture complete — tasks ready${feature}`,
+      implementation_complete: `Implementation complete${feature} — use !review`,
+      implementation_failed:   `Implementation failed${feature}: ${(status.error || '').slice(0, 80)}`,
+      review_complete:         `Review complete${feature} — use !approve or !reject`,
+      approved:                `Feature approved${feature} — use !deploy`,
+      rejected:                `Feature rejected${feature} — fixes needed`,
+      deployed:                `Deployment complete!${feature}`,
+    };
+
+    const msg = stageMessages[status.stage];
+    if (msg) {
+      bot.say(truncate(msg));
+    }
+  });
+}

package/lib/utils/achievements.js

@@ -0,0 +1,191 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+const STATS_DIR = '.ai-workflow';
+const STATS_FILE = join(STATS_DIR, 'stats.json');
+const ACHIEVEMENTS_FILE = join(STATS_DIR, 'achievements.json');
+
+export const ACHIEVEMENTS = {
+  FIRST_FEATURE: { id: 'first-feature', name: 'First Steps', emoji: '🎯', description: 'Submit your first feature', condition: (stats) => stats.features >= 1 },
+  TEN_FEATURES: { id: 'ten-features', name: 'Feature Factory', emoji: '🏭', description: 'Submit 10 features', condition: (stats) => stats.features >= 10 },
+  FIFTY_FEATURES: { id: 'fifty-features', name: 'Feature Machine', emoji: '⚡', description: 'Submit 50 features', condition: (stats) => stats.features >= 50 },
+  FIRST_DEPLOY: { id: 'first-deploy', name: 'Ship It!', emoji: '🚀', description: 'Complete your first deploy', condition: (stats) => stats.deploys >= 1 },
+  FIRST_REVIEW: { id: 'first-review', name: 'Code Inspector', emoji: '🔍', description: 'Complete your first review', condition: (stats) => stats.reviews >= 1 },
+  COST_SAVER: { id: 'cost-saver', name: 'Budget Hawk', emoji: '💰', description: 'Complete a feature under $0.10', condition: (stats) => stats.cheapestFeature < 0.10 },
+  SPEED_DEMON: { id: 'speed-demon', name: 'Speed Demon', emoji: '⏱️', description: 'Complete a feature in under 60 seconds', condition: (stats) => stats.fastestFeature < 60000 },
+  NIGHT_OWL: { id: 'night-owl', name: 'Night Owl', emoji: '🦉', description: 'Run a pipeline after midnight', condition: (stats) => stats.nightRuns >= 1 },
+  MULTI_MODEL: { id: 'multi-model', name: 'Model Mixer', emoji: '🧪', description: 'Use 3 different AI models', condition: (stats) => stats.modelsUsed >= 3 },
+  STREAK_3: { id: 'streak-3', name: 'On a Roll', emoji: '🔥', description: '3 successful pipelines in a row', condition: (stats) => stats.currentStreak >= 3 },
+  STREAK_10: { id: 'streak-10', name: 'Unstoppable', emoji: '💎', description: '10 successful pipelines in a row', condition: (stats) => stats.currentStreak >= 10 },
+  HUNDRED_PIPELINES: { id: 'hundred-pipelines', name: 'Centurion', emoji: '🏛️', description: 'Run 100 pipelines', condition: (stats) => stats.totalPipelines >= 100 },
+  PERFECT_REVIEW: { id: 'perfect-review', name: 'Perfectionist', emoji: '✨', description: 'Get a review with no issues', condition: (stats) => stats.perfectReviews >= 1 },
+  TEAM_PLAYER: { id: 'team-player', name: 'Team Player', emoji: '🤝', description: 'Use webhooks or Slack integration', condition: (stats) => stats.integrationsUsed >= 1 },
+  CUSTOMIZER: { id: 'customizer', name: 'Make It Yours', emoji: '🎨', description: 'Create a custom persona', condition: (stats) => stats.customPersonas >= 1 },
+};
+
+function getDefaultStats() {
+  return {
+    features: 0,
+    deploys: 0,
+    reviews: 0,
+    totalPipelines: 0,
+    currentStreak: 0,
+    bestStreak: 0,
+    cheapestFeature: Infinity,
+    fastestFeature: Infinity,
+    nightRuns: 0,
+    modelsUsed: 0,
+    modelsSet: [],
+    perfectReviews: 0,
+    integrationsUsed: 0,
+    customPersonas: 0,
+    totalCost: 0,
+  };
+}
+
+export function getStats() {
+  if (!existsSync(STATS_DIR)) {
+    mkdirSync(STATS_DIR, { recursive: true });
+  }
+  if (!existsSync(STATS_FILE)) {
+    const defaults = getDefaultStats();
+    writeFileSync(STATS_FILE, JSON.stringify(defaults, null, 2));
+    return defaults;
+  }
+  try {
+    return JSON.parse(readFileSync(STATS_FILE, 'utf-8'));
+  } catch {
+    return getDefaultStats();
+  }
+}
+
+export function updateStats(update) {
+  const stats = getStats();
+  Object.assign(stats, update);
+  if (!existsSync(STATS_DIR)) {
+    mkdirSync(STATS_DIR, { recursive: true });
+  }
+  writeFileSync(STATS_FILE, JSON.stringify(stats, null, 2));
+  return stats;
+}
+
+export function checkAchievements(stats) {
+  const unlocked = getUnlockedAchievements();
+  const newlyUnlocked = [];
+  for (const achievement of Object.values(ACHIEVEMENTS)) {
+    if (!unlocked.includes(achievement.id) && achievement.condition(stats)) {
+      newlyUnlocked.push(achievement);
+    }
+  }
+  return newlyUnlocked;
+}
+
+export function getUnlockedAchievements() {
+  if (!existsSync(ACHIEVEMENTS_FILE)) {
+    return [];
+  }
+  try {
+    const data = JSON.parse(readFileSync(ACHIEVEMENTS_FILE, 'utf-8'));
+    return data.map((a) => a.id);
+  } catch {
+    return [];
+  }
+}
+
+export function unlockAchievement(achievementId) {
+  if (!existsSync(STATS_DIR)) {
+    mkdirSync(STATS_DIR, { recursive: true });
+  }
+  let achievements = [];
+  if (existsSync(ACHIEVEMENTS_FILE)) {
+    try {
+      achievements = JSON.parse(readFileSync(ACHIEVEMENTS_FILE, 'utf-8'));
+    } catch {
+      achievements = [];
+    }
+  }
+  if (!achievements.some((a) => a.id === achievementId)) {
+    achievements.push({ id: achievementId, unlockedAt: new Date().toISOString() });
+    writeFileSync(ACHIEVEMENTS_FILE, JSON.stringify(achievements, null, 2));
+  }
+}
+
+export function formatAchievementNotification(achievement) {
+  return `🏆 Achievement Unlocked: ${achievement.emoji} ${achievement.name} - ${achievement.description}`;
+}
+
+export function formatAchievementList(unlockedIds) {
+  const lines = ['🏆 Achievements\n'];
+  for (const achievement of Object.values(ACHIEVEMENTS)) {
+    const isUnlocked = unlockedIds.includes(achievement.id);
+    const status = isUnlocked ? '✅' : '🔒';
+    const display = isUnlocked
+      ? `${status} ${achievement.emoji} ${achievement.name} - ${achievement.description}`
+      : `${status} ??? - ${achievement.description}`;
+    lines.push(display);
+  }
+  const total = Object.values(ACHIEVEMENTS).length;
+  const unlocked = unlockedIds.length;
+  lines.push(`\n${unlocked}/${total} Achievements Unlocked`);
+  return lines.join('\n');
+}
+
+export function trackPipelineCompletion(result) {
+  const { action, duration, cost, model, success, reviewIssues } = result;
+  const stats = getStats();
+
+  stats.totalPipelines += 1;
+
+  if (action === 'feature' || action === 'implement') {
+    stats.features += 1;
+  }
+  if (action === 'deploy') {
+    stats.deploys += 1;
+  }
+  if (action === 'review') {
+    stats.reviews += 1;
+  }
+
+  if (success) {
+    stats.currentStreak += 1;
+    if (stats.currentStreak > stats.bestStreak) {
+      stats.bestStreak = stats.currentStreak;
+    }
+  } else {
+    stats.currentStreak = 0;
+  }
+
+  if (cost !== undefined && cost < stats.cheapestFeature) {
+    stats.cheapestFeature = cost;
+  }
+  if (duration !== undefined && duration < stats.fastestFeature) {
+    stats.fastestFeature = duration;
+  }
+  if (cost !== undefined) {
+    stats.totalCost += cost;
+  }
+
+  const hour = new Date().getHours();
+  if (hour >= 0 && hour < 6) {
+    stats.nightRuns += 1;
+  }
+
+  if (model && !stats.modelsSet.includes(model)) {
+    stats.modelsSet.push(model);
+    stats.modelsUsed = stats.modelsSet.length;
+  }
+
+  if (reviewIssues === 0) {
+    stats.perfectReviews += 1;
+  }
+
+  updateStats(stats);
+
+  const newAchievements = checkAchievements(stats);
+  const notifications = [];
+  for (const achievement of newAchievements) {
+    unlockAchievement(achievement.id);
+    notifications.push(formatAchievementNotification(achievement));
+  }
+  return notifications;
+}

package/lib/utils/activity-log.js

@@ -0,0 +1,182 @@
+import chalk from 'chalk';
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { getConfig } from '../config.js';
+import { spinner } from './spinner.js';
+import { statusBar } from './status-bar.js';
+
+// All labels exactly 8 ASCII chars — perfect column alignment guaranteed.
+// NO emoji — emoji are double-width in terminals and break alignment.
+const AI_STYLES = {
+  CLAUDE:   { color: 'magenta', label: 'CLAUDE  ' },
+  GEMINI:   { color: 'cyan',    label: 'GEMINI  ' },
+  COPILOT:  { color: 'blue',    label: 'COPILOT ' },
+  PIPELINE: { color: 'yellow',  label: 'PIPELINE' },
+  SYSTEM:   { color: 'white',   label: 'SYSTEM  ' },
+};
+
+// Single-width chars only — no emoji
+const STATUS_CHAR = {
+  success: chalk.green('✓'),
+  error:   chalk.red('✗'),
+  warn:    chalk.yellow('~'),
+  info:    chalk.dim('·'),
+};
+
+const STATUS_TEXT = {
+  success: 'SUCCESS',
+  error:   'ERROR  ',
+  warn:    'WARN   ',
+  info:    'INFO   ',
+};
+
+// ─── Session Log File ─────────────────────────────────────────────────────────
+// Captures ALL agent output to a plain-text file, including lines suppressed
+// by the terminal spinner. Use to audit what each AI actually did.
+
+let _logFile = null;  // absolute path to current session log
+
+/**
+ * Strip ANSI escape codes for clean plain-text log files.
+ */
+function stripAnsi(str) {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B\[[0-9;]*[mGKHF]/g, '');
+}
+
+/**
+ * Write a line to the session log file (plain text, no ANSI).
+ * Never throws — logging must not break the main flow.
+ */
+function writeLog(agent, type, message, isRaw = false) {
+  if (!_logFile) return;
+  try {
+    const now    = new Date();
+    const date   = now.toLocaleDateString('en-CA');  // YYYY-MM-DD
+    const time   = now.toLocaleTimeString('en-AU', { hour12: false }); // HH:MM:SS
+    const label  = (AI_STYLES[agent]?.label || 'SYSTEM  ');
+    const status = isRaw ? 'RAW    ' : (STATUS_TEXT[type] || STATUS_TEXT.info);
+    const clean  = stripAnsi(String(message)).trim();
+    appendFileSync(_logFile, `[${date} ${time}] [${label}] [${status}]  ${clean}\n`, 'utf8');
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Initialize a new session log file.
+ * Call once at startup. Creates .ai-workflow/logs/session-YYYYMMDD-HHMMSS.log
+ *
+ * @param {string} workflowDir  — absolute path to .ai-workflow/
+ */
+export function initSessionLog(workflowDir) {
+  try {
+    const logsDir = resolve(workflowDir, 'logs');
+    if (!existsSync(logsDir)) mkdirSync(logsDir, { recursive: true });
+
+    const now     = new Date();
+    const stamp   = now.toISOString().replace(/[:.]/g, '-').slice(0, 19); // 2026-02-24T22-38-25
+    _logFile = resolve(logsDir, `session-${stamp}.log`);
+
+    appendFileSync(_logFile,
+      `${'='.repeat(72)}\n` +
+      `${(() => { try { return getConfig().name; } catch { return 'AI Control Center'; } })()} — Session Log\n` +
+      `Started: ${now.toLocaleString('en-AU')}\n` +
+      `Log file: ${_logFile}\n` +
+      `${'='.repeat(72)}\n\n`,
+      'utf8'
+    );
+    // Tell the status bar which log file to show in the info row
+    statusBar.setLogFile(_logFile);
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Returns the current session log file path (or null if not initialised).
+ */
+export function getSessionLogFile() {
+  return _logFile;
+}
+
+/**
+ * Write a large multi-line block to the session log FILE ONLY (not terminal).
+ * Use for full AI outputs, deploy JSON, fix guides — anything too large for
+ * the terminal but important to preserve in the audit log.
+ *
+ * Format in log file:
+ *   ── COPILOT OUTPUT ──────────────────
+ *   line 1
+ *   line 2
+ *   ────────────────────────────────────
+ */
+export function logRawBlock(agent, label, content) {
+  if (!_logFile || !content) return;
+  try {
+    const now    = new Date();
+    const date   = now.toLocaleDateString('en-CA');
+    const time   = now.toLocaleTimeString('en-AU', { hour12: false });
+    const header = `[${date} ${time}] [${(AI_STYLES[agent]?.label || 'SYSTEM  ')}] ── ${label} ${'─'.repeat(Math.max(0, 40 - label.length))}\n`;
+    const body   = stripAnsi(String(content)).split('\n').map(l => `  ${l}`).join('\n');
+    const footer = `[${date} ${time}] [${(AI_STYLES[agent]?.label || 'SYSTEM  ')}] ${'─'.repeat(48)}\n`;
+    appendFileSync(_logFile, `${header}${body}\n${footer}\n`, 'utf8');
+  } catch { /* non-fatal */ }
+}
+
+function timestamp() {
+  return chalk.dim(new Date().toLocaleTimeString('en-AU', { hour12: false }));
+}
+
+/**
+ * Log a milestone activity line.
+ * Automatically pauses/resumes the spinner so lines never mix.
+ * Also writes to session log file.
+ *
+ * Format:  12:34:56  GEMINI    ✓  message
+ */
+export function logActivity(ai, message, type = 'info') {
+  const style  = AI_STYLES[ai] || AI_STYLES.SYSTEM;
+  const ts     = timestamp();
+  const label  = chalk[style.color].bold(style.label);
+  const status = STATUS_CHAR[type] || STATUS_CHAR.info;
+
+  spinner.pause();
+  console.log(`  ${ts}  ${label}  ${status}  ${message}`);
+  spinner.resume();
+
+  writeLog(ai, type, message);
+  // Keep info row up to date with latest milestone
+  statusBar.setLastEvent(ai, message);
+}
+
+/**
+ * Log a raw subprocess output line to the session log FILE ONLY.
+ * Raw streaming output (every stdout/stderr line from Gemini/Copilot/Claude)
+ * is too noisy for the terminal. Only milestone events via logActivity()
+ * are shown in the terminal. Full detail is always in the session log.
+ */
+export function logActivityLine(ai, line) {
+  if (line.trim()) writeLog(ai, 'info', line, true);
+  // Intentionally no terminal output — use logActivity() for milestones.
+}
+
+/**
+ * Section header — full-width right-fill adapts to terminal.
+ * Format:  ◆  Title  ─────────────────────────────
+ */
+export function printActivityHeader(title) {
+  const cols  = process.stdout.columns || 80;
+  const used  = 5 + title.length + 2; // '  ◆  ' + title + '  '
+  const right = chalk.dim('─'.repeat(Math.max(0, cols - used)));
+
+  console.log('');
+  console.log(`  ${chalk.cyan.bold('◆')}  ${chalk.bold.white(title)}  ${right}`);
+
+  writeLog('SYSTEM', 'info', `=== ${title} ===`);
+}
+
+/**
+ * Section footer — full-width divider.
+ */
+export function printActivityFooter() {
+  const cols = process.stdout.columns || 80;
+  console.log(chalk.dim('─'.repeat(cols)));
+  console.log('');
+}

package/lib/utils/agent-leaderboard.js

@@ -0,0 +1,119 @@
+import { getCostEntries } from './cost-tracker.js';
+
+export function getLeaderboard(limit = 10) {
+  const entries = getCostEntries();
+  if (entries.length === 0) return [];
+
+  const stats = {};
+  for (const entry of entries) {
+    const key = `${entry.provider || 'unknown'}:${entry.model || 'default'}`;
+    if (!stats[key]) {
+      stats[key] = {
+        provider: entry.provider || 'unknown',
+        model: entry.model || 'default',
+        calls: 0,
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCost: 0,
+        errors: 0,
+        totalDurationMs: 0,
+        stages: new Set(),
+        features: new Set(),
+      };
+    }
+    const s = stats[key];
+    s.calls++;
+    s.totalInputTokens += entry.inputTokens || 0;
+    s.totalOutputTokens += entry.outputTokens || 0;
+    s.totalCost += entry.estimatedCost || 0;
+    s.totalDurationMs += entry.durationMs || 0;
+    if (entry.error) s.errors++;
+    if (entry.stage) s.stages.add(entry.stage);
+    if (entry.featureId) s.features.add(entry.featureId);
+  }
+
+  return Object.values(stats)
+    .map(s => ({
+      provider: s.provider,
+      model: s.model,
+      calls: s.calls,
+      totalTokens: s.totalInputTokens + s.totalOutputTokens,
+      totalCost: s.totalCost,
+      avgCostPerCall: s.calls > 0 ? s.totalCost / s.calls : 0,
+      errors: s.errors,
+      errorRate: s.calls > 0 ? (s.errors / s.calls * 100) : 0,
+      avgDurationMs: s.calls > 0 ? s.totalDurationMs / s.calls : 0,
+      stages: Array.from(s.stages),
+      features: s.features.size,
+      reliability: s.calls > 0 ? ((s.calls - s.errors) / s.calls * 100) : 100,
+      costEfficiency: s.totalCost > 0 ? (s.totalInputTokens + s.totalOutputTokens) / s.totalCost : 0,
+    }))
+    .sort((a, b) => a.avgCostPerCall - b.avgCostPerCall)
+    .slice(0, limit);
+}
+
+export function formatLeaderboard(entries) {
+  if (entries.length === 0) return '📊 No usage data yet. Run some pipelines first!';
+
+  const lines = ['🏆 AI Model Leaderboard\n'];
+
+  const bestValue = entries.reduce((best, e) => e.avgCostPerCall < best.avgCostPerCall ? e : best, entries[0]);
+  const mostReliable = entries.reduce((best, e) => e.reliability > best.reliability ? e : best, entries[0]);
+  const mostUsed = entries.reduce((best, e) => e.calls > best.calls ? e : best, entries[0]);
+
+  entries.forEach((e, i) => {
+    const badges = [];
+    if (e === bestValue) badges.push('💰 Best Value');
+    if (e === mostReliable && e.calls > 2) badges.push('🛡️ Most Reliable');
+    if (e === mostUsed) badges.push('⭐ Most Used');
+
+    const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `#${i + 1}`;
+    lines.push(
+      `${medal} ${e.provider}/${e.model}` +
+      (badges.length > 0 ? ` ${badges.join(' ')}` : '')
+    );
+    lines.push(
+      `   ${e.calls} calls · $${e.avgCostPerCall.toFixed(4)}/call · ` +
+      `${e.reliability.toFixed(0)}% reliability · ${Math.round(e.avgDurationMs / 1000)}s avg`
+    );
+    lines.push(
+      `   ${e.totalTokens.toLocaleString()} tokens · $${e.totalCost.toFixed(4)} total · ` +
+      `${e.features} features`
+    );
+    lines.push('');
+  });
+
+  return lines.join('\n');
+}
+
+export function formatLeaderboardHTML(entries) {
+  if (entries.length === 0) return '<p>No usage data yet.</p>';
+
+  return `
+    <div class="leaderboard">
+      <h3>🏆 AI Model Leaderboard</h3>
+      <table style="width:100%;border-collapse:collapse;font-size:12px">
+        <tr style="border-bottom:1px solid #334155">
+          <th style="text-align:left;padding:6px">#</th>
+          <th style="text-align:left;padding:6px">Model</th>
+          <th style="text-align:right;padding:6px">Calls</th>
+          <th style="text-align:right;padding:6px">$/Call</th>
+          <th style="text-align:right;padding:6px">Reliability</th>
+          <th style="text-align:right;padding:6px">Avg Time</th>
+          <th style="text-align:right;padding:6px">Total $</th>
+        </tr>
+        ${entries.map((e, i) => `
+          <tr style="border-bottom:1px solid #1e293b">
+            <td style="padding:6px">${i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : i + 1}</td>
+            <td style="padding:6px">${e.provider}/${e.model}</td>
+            <td style="text-align:right;padding:6px">${e.calls}</td>
+            <td style="text-align:right;padding:6px">$${e.avgCostPerCall.toFixed(4)}</td>
+            <td style="text-align:right;padding:6px;color:${e.reliability > 95 ? '#22c55e' : e.reliability > 80 ? '#f59e0b' : '#ef4444'}">${e.reliability.toFixed(0)}%</td>
+            <td style="text-align:right;padding:6px">${Math.round(e.avgDurationMs / 1000)}s</td>
+            <td style="text-align:right;padding:6px">$${e.totalCost.toFixed(4)}</td>
+          </tr>
+        `).join('')}
+      </table>
+    </div>
+  `;
+}