ai-control-center 1.15.2

package/lib/index.js

@@ -0,0 +1,471 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { approveAction } from './actions/approve.js';
+import { cleanupAction } from './actions/cleanup.js';
+import { debugAction } from './actions/debug.js';
+import { deployAction } from './actions/deploy.js';
+import { fixBugAction } from './actions/fix-bug.js';
+import { newFeatureAction } from './actions/new-feature.js';
+import { rejectAction } from './actions/reject.js';
+import { reviewAction } from './actions/review.js';
+import { showStatusAction } from './actions/status.js';
+import { initSessionLog } from './utils/activity-log.js';
+import { printHeader } from './utils/display.js';
+import { getStatus, getWorkflowDir, updateStatus } from './utils/pipeline.js';
+import { statusBar } from './utils/status-bar.js';
+import { AILimitError } from './utils/runner.js';
+
+// ─── Tab navigation shim ───────────────────────────────────────────────────────
+//
+// Intercepts raw stdin data BEFORE readline/inquirer processes it.
+// Converts:
+//   Tab         (0x09)     → Down arrow  (ESC[B)
+//   Shift+Tab   (ESC[Z)    → Up arrow    (ESC[A)
+//
+// This lets Terminus (iPhone) users navigate with Tab/Shift+Tab
+// instead of needing arrow keys.
+
+function enableTabNavigation() {
+  const _emit = process.stdin.emit.bind(process.stdin);
+
+  process.stdin.emit = function (event, data, ...rest) {
+    if (event === 'data') {
+      const buf = Buffer.isBuffer(data) ? data : Buffer.from(String(data));
+
+      // Tab → Down arrow
+      if (buf.length === 1 && buf[0] === 0x09) {
+        return _emit('data', Buffer.from('\x1B[B'), ...rest);
+      }
+
+      // Shift+Tab → Up arrow
+      if (buf.toString() === '\x1B[Z') {
+        return _emit('data', Buffer.from('\x1B[A'), ...rest);
+      }
+    }
+
+    return _emit(event, data, ...rest);
+  };
+}
+
+enableTabNavigation();
+statusBar.install(inquirer);
+
+// Start a fresh session log file for this run
+initSessionLog(getWorkflowDir());
+
+// ─── Menu item helper ──────────────────────────────────────────────────────────
+// num   — dimmed number prefix; user can type to jump (inquirer type-to-search)
+// label — padded to a fixed width so badges always start in the same column
+// badge — status hint; shown right after the padded label
+
+const LABEL_WIDTH = 26; // fixed label column width (adjust if labels grow)
+
+function item(num, label, badge = '', badgeColor = 'dim') {
+  const n       = chalk.dim(`${num} `);
+  const padded  = label.padEnd(LABEL_WIDTH);
+  const text    = badge
+    ? `${padded}  ${chalk[badgeColor](badge)}`
+    : padded;
+  return n + text;
+}
+
+function sep() {
+  return new inquirer.Separator(chalk.dim('  ' + '─'.repeat(48)));
+}
+
+// ─── Reliable "press Enter" via inquirer ──────────────────────────────────────
+
+async function pressEnterToContinue() {
+  await inquirer.prompt([{
+    type:    'input',
+    name:    '_',
+    message: chalk.dim('Back to menu'),
+    prefix:  chalk.dim('↵'),
+  }]);
+}
+
+// ─── Smart Navigation: Suggest Next Step ──────────────────────────────────────
+// Uses rawlist so the user can type a number + Enter — works on mobile (Terminus)
+// without needing arrow keys.
+
+async function promptNextStep(status) {
+  const { stage } = status;
+
+  // Build context-aware choices for each pipeline stage
+  const contextChoices = [];
+
+  if (stage === 'implementation_complete') {
+    contextChoices.push({ name: `1  ${'Review Code'.padEnd(24)}  run Gemini review`, value: 'review' });
+    contextChoices.push({ name: `2  ${'Reject / Request Fixes'.padEnd(24)}  skip review, dispatch to Copilot`, value: 'reject' });
+  } else if (stage === 'rejected') {
+    contextChoices.push({ name: `1  ${'Review Code'.padEnd(24)}  re-review after fixes`, value: 'review' });
+    contextChoices.push({ name: `2  ${'Re-send to Copilot'.padEnd(24)}  dispatch existing review`, value: 'reject' });
+  } else if (stage === 'review_complete') {
+    console.log(chalk.green('\n  ✓  Review complete — ready for approval'));
+    contextChoices.push({ name: `1  ${'Approve Feature'.padEnd(24)}  mark approved, then deploy`, value: 'approve' });
+    contextChoices.push({ name: `2  ${'Reject / Request Fixes'.padEnd(24)}  send blockers to Copilot`, value: 'reject' });
+  } else if (stage === 'approved') {
+    console.log(chalk.green('\n  ✓  Feature approved — ready to deploy'));
+    contextChoices.push({ name: `1  ${'Deploy to Org'.padEnd(24)}  deploy now`, value: 'deploy' });
+  } else if (stage === 'arch_complete') {
+    contextChoices.push({ name: `1  ${'Review Code'.padEnd(24)}  force review (skip Copilot)`, value: 'review' });
+  }
+
+  // No relevant next action for this stage — just go back to menu
+  if (contextChoices.length === 0) {
+    await pressEnterToContinue();
+    return null;
+  }
+
+  contextChoices.push({ name: `S  ${'Pipeline Status'.padEnd(24)}  view current stage`, value: 'status' });
+  contextChoices.push({ name: `M  ${'Main Menu'.padEnd(24)}  back`, value: 'menu' });
+
+  console.log(chalk.dim('\n  ─────────────────────────────────────────────────────'));
+
+  const { choice } = await inquirer.prompt([{
+    type:    'rawlist',
+    name:    'choice',
+    message: 'What next?',
+    prefix:  chalk.cyan('◆'),
+    choices: contextChoices,
+  }]);
+
+  return choice === 'menu' ? null : choice;
+}
+
+// ─── Auto-Pilot Logic ─────────────────────────────────────────────────────────
+const AUTO_PILOT_MAX_RUNS = 3;  // max auto review+fix cycles before handing back to user
+
+async function runAutoPilot(status) {
+  const { stage } = status;
+  const runs = status.auto_review_count || 0;
+
+  // 1. Stop at Deployment — notify user and switch to manual
+  if (stage === 'review_complete' || stage === 'approved') {
+    process.stdout.write('\x07'); // terminal bell
+    console.log(chalk.green('\n  ✓  Auto-Pilot: Feature ready — choose Approve or Deploy below'));
+    updateStatus({ pipeline_mode: 'manual', auto_review_count: 0 });
+    return null;
+  }
+
+  // 2. Max runs reached — stop auto-pilot and hand back to user
+  if (runs >= AUTO_PILOT_MAX_RUNS) {
+    process.stdout.write('\x07'); // terminal bell
+    console.log(chalk.yellow(
+      `\n  ⚠  Auto-Pilot stopped after ${AUTO_PILOT_MAX_RUNS} review attempts — manual intervention needed.`
+    ));
+    updateStatus({ pipeline_mode: 'manual', auto_review_count: 0 });
+    return null;
+  }
+
+  // 3. Auto-Review Loop (implementation_complete or rejected → review → fix → loop)
+  if (stage === 'implementation_complete' || (stage === 'rejected' && status.next === 'review')) {
+    console.log(chalk.cyan(
+      `\n  ⚡  Auto-Pilot: running review (attempt ${runs + 1} / ${AUTO_PILOT_MAX_RUNS})...`
+    ));
+    updateStatus({ auto_review_count: runs + 1 });
+    await reviewAction();
+    return 'continue'; // Loop again
+  }
+
+  // 4. Unrecognised stage — pause and ask user to intervene
+  console.log(chalk.yellow(`\n  Auto-Pilot paused: stage "${stage}" requires manual input.`));
+  updateStatus({ pipeline_mode: 'manual', auto_review_count: 0 });
+  return null;
+}
+
+// ─── Reset / Abandon feature ──────────────────────────────────────────────────
+
+async function resetFeatureAction(status) {
+  const { confirmed } = await inquirer.prompt([{
+    type:    'confirm',
+    name:    'confirmed',
+    message: chalk.red(`Abandon "${status.current_feature}" and reset to idle?`),
+    default: false,
+  }]);
+
+  if (!confirmed) {
+    console.log(chalk.dim('\n  Cancelled.\n'));
+    return;
+  }
+
+  updateStatus({ stage: 'idle', current_feature: null, next: null, pipeline_mode: null });
+  console.log(chalk.green('\n  ✓  Feature abandoned — pipeline reset to idle.\n'));
+}
+
+// ─── Main loop ─────────────────────────────────────────────────────────────────
+
+async function mainMenu() {
+  let nextAction = null;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const status  = getStatus();
+
+    // ─── Auto-Pilot Check ───
+    if (status.pipeline_mode === 'auto' && !nextAction) {
+      const autoResult = await runAutoPilot(status);
+      if (autoResult === 'continue') continue;
+    }
+
+    if (!nextAction) {
+      printHeader();
+    }
+
+    const stage   = status.stage || 'idle';
+    const hasFeature    = !!status.current_feature;
+    const isReviewReady = stage === 'review_complete';
+
+    // Stages where Gemini review can run (includes stuck/partial pipeline stages)
+    const canReview = hasFeature && [
+      'inbox', 'spec_complete',
+      'arch_complete', 'implementation_complete', 'rejected', 'review_complete',
+    ].includes(stage);
+
+    // Pipeline is active (not yet approved/idle)
+    const isPipelineActive = hasFeature && !['approved', 'idle'].includes(stage);
+
+    const reviewBadge = isReviewReady
+      ? ['(ready)', 'green']
+      : stage === 'rejected'
+        ? ['(re-review after fixes)', 'yellow']
+        : stage === 'inbox' || stage === 'spec_complete'
+          ? ['(pipeline stuck — force review)', 'yellow']
+          : canReview
+            ? ['(run after Copilot implements)', 'yellow']
+            : ['(no active feature)', 'dim'];
+
+    const deployBadge = stage === 'approved'
+      ? ['(ready!)', 'green']
+      : isPipelineActive
+        ? ['(not approved yet)', 'yellow']
+        : ['', 'dim'];
+
+    const autoBadge = status.pipeline_mode === 'auto' ? ['auto  ON', 'cyan'] : ['auto  off', 'dim'];
+
+    // ── Menu choices ────────────────────────────────────────────────────────────
+    // Labels padded to LABEL_WIDTH so all badges align in one column.
+    // Numbers let mobile users type a digit + Enter to jump directly.
+    const choices = [
+      { name: item(1, 'New Feature',      'start the full pipeline (Gemini → Claude → Copilot)', 'dim'), value: 'new-feature' },
+      { name: item(2, 'Fix a Bug',        'submit a bug fix through the same pipeline',           'dim'), value: 'fix-bug' },
+
+      sep(),
+
+      {
+        name:     item(3, 'Review Code',      ...reviewBadge),
+        value:    'review',
+        disabled: !canReview && !isReviewReady,
+      },
+
+      sep(),
+
+      {
+        name: isReviewReady
+          ? item(4, 'Approve Feature',    'mark as approved — enables Deploy',  'green')
+          : item(4, 'Approve Feature',    'requires review_complete',           'dim'),
+        value:    'approve',
+        disabled: !isReviewReady,
+      },
+      {
+        name: !hasFeature
+          ? item(5, 'Reject / Request Fixes', 'no active feature',                        'dim')
+          : stage === 'rejected'
+            ? item(5, 'Re-send Fixes to Copilot', 're-dispatch existing review → Copilot', 'yellow')
+            : item(5, 'Reject / Request Fixes',
+                isReviewReady || stage === 'arch_complete' || stage === 'implementation_complete'
+                  ? 'dispatch blockers → Copilot' : 'flag issue', 'red'),
+        value:    'reject',
+        disabled: !hasFeature,
+      },
+
+      sep(),
+
+      { name: item(6, 'Deploy to Org',        ...deployBadge),          value: 'deploy' },
+      { name: item(7, 'Debug / View Logs',     'Apex logs, tests, org', 'dim'), value: 'debug' },
+
+      sep(),
+
+      { name: item(8, 'Pipeline Status',       'show stage history',    'dim'), value: 'status' },
+      { name: item(9, 'Clean Up Workspace',    'archive workflow files','dim'), value: 'cleanup' },
+
+      sep(),
+
+      { name: item('Q', 'Browser QA',          'run Playwright QA on target website', 'cyan'), value: 'browser-qa' },
+      { name: item('S', 'AI Suggestions',      'generate feature suggestions',        'cyan'), value: 'suggest' },
+      { name: item('P', 'Assign Project',      'assign URL + goal to AI IT dept',     'cyan'), value: 'assign-project' },
+
+      sep(),
+
+      { name: item('A', 'Toggle Auto-Pilot',   ...autoBadge), value: 'toggle-auto', disabled: !isPipelineActive },
+      {
+        name: isPipelineActive
+          ? item('R', 'Reset / Abandon',       status.current_feature || '', 'red')
+          : item('R', 'Reset / Abandon',       'no active feature',          'dim'),
+        value:    'reset',
+        disabled: !isPipelineActive,
+      },
+
+      sep(),
+
+      { name: chalk.dim(`  0  ${'Exit'.padEnd(LABEL_WIDTH)}`), value: 'exit' },
+    ];
+
+    let action = nextAction;
+
+    if (!action) {
+      // Keyboard hint — shown once just above the prompt (not in every header)
+      console.log(chalk.dim('  Tab / Shift+Tab  navigate    1-9 A R  jump    0  exit'));
+      console.log('');
+
+      const { action: selected } = await inquirer.prompt([{
+        type:     'list',
+        name:     'action',
+        message:  'What would you like to do?',
+        prefix:   chalk.cyan('◆'),
+        choices,
+        pageSize: 20,
+      }]);
+      action = selected;
+    } else {
+      nextAction = null;
+    }
+
+    if (action === 'exit') {
+      console.log(chalk.dim('\n  Goodbye.\n'));
+      process.exit(0);
+    }
+
+    let actionCompleted = false;
+    try {
+      switch (action) {
+        case 'new-feature':
+          actionCompleted = await newFeatureAction('feature');
+          break;
+        case 'fix-bug':     actionCompleted = await fixBugAction();    break;
+        case 'review':      actionCompleted = await reviewAction();    break;
+        case 'approve':     actionCompleted = await approveAction();   break;
+        case 'reject':      actionCompleted = await rejectAction();    break;
+        case 'deploy':      actionCompleted = await deployAction();    break;
+        case 'debug':       await debugAction();              break;
+        case 'status':      showStatusAction();               break;
+        case 'cleanup':     await cleanupAction(false);       break;
+        case 'reset':       await resetFeatureAction(status); break;
+        case 'browser-qa': {
+          console.log(chalk.cyan('\n  🔬 Running Browser QA...\n'));
+          try {
+            const { browserTestAction } = await import('./actions/browser-test.js');
+            const qaResult = await browserTestAction();
+            if (qaResult.skipped) {
+              console.log(chalk.yellow('  Browser QA disabled. Enable in aicc.config.js: browserQA.enabled = true'));
+            } else if (qaResult.report?.summary) {
+              const s = qaResult.report.summary;
+              const icon = s.failed === 0 ? chalk.green('✅') : chalk.red('❌');
+              console.log(`  ${icon}  ${s.passed}/${s.totalRoutes} passed (${s.passRate}% pass rate)`);
+              if (s.failed > 0) console.log(chalk.red(`     ${s.failed} page(s) failed — check .ai-workflow/qa-reports/`));
+            }
+          } catch (qaErr) {
+            console.log(chalk.red(`  QA failed: ${qaErr.message}`));
+          }
+          break;
+        }
+        case 'suggest': {
+          console.log(chalk.cyan('\n  💡 Running Suggestion Agent...\n'));
+          try {
+            const { runSuggestionAgent } = await import('./agents/suggestion-agent.js');
+            const sugResult = await runSuggestionAgent();
+            if (sugResult.skipped) {
+              console.log(chalk.yellow('  Suggestion agent disabled in config.'));
+            } else if (sugResult.suggestions?.length > 0) {
+              for (const [i, s] of sugResult.suggestions.entries()) {
+                console.log(`  ${i + 1}. ${chalk.white(s.title)}  [${s.priority}/${s.effort}]`);
+                console.log(chalk.dim(`     ${s.why || s.description || ''}`));
+              }
+              console.log(chalk.dim(`\n  Saved to: ${sugResult.filePath}`));
+            } else {
+              console.log('  No suggestions generated.');
+            }
+          } catch (sugErr) {
+            console.log(chalk.red(`  Suggestion failed: ${sugErr.message}`));
+          }
+          break;
+        }
+        case 'assign-project': {
+          const { url: assignUrl } = await inquirer.prompt([{ type: 'input', name: 'url', message: 'Target URL:' }]);
+          const { goal: assignGoal } = await inquirer.prompt([{ type: 'input', name: 'goal', message: 'Project goal:' }]);
+          if (!assignUrl || !assignGoal) { console.log(chalk.yellow('  URL and goal are required.')); break; }
+          console.log(chalk.cyan(`\n  🎯 Assigning project: ${assignUrl}\n`));
+          try {
+            const { assignProjectAction } = await import('./actions/assign-project.js');
+            const aResult = await assignProjectAction({ url: assignUrl, goal: assignGoal });
+            if (aResult.success) {
+              console.log(chalk.green(`  ✅  Project assigned: ${aResult.projectId}`));
+              console.log(chalk.dim('     The autonomous loop will start Browser QA next.'));
+            } else {
+              console.log(chalk.red('  Assignment failed.'));
+            }
+          } catch (aErr) {
+            console.log(chalk.red(`  Assignment failed: ${aErr.message}`));
+          }
+          break;
+        }
+        case 'toggle-auto':
+          updateStatus({ pipeline_mode: status.pipeline_mode === 'auto' ? 'manual' : 'auto' });
+          console.log(chalk.cyan(`\n  ⚡ Auto-Pilot is now ${status.pipeline_mode === 'auto' ? 'OFF' : 'ON'}\n`));
+          break;
+      }
+    } catch (err) {
+      if (err instanceof AILimitError) {
+        // ── AI usage / rate limit hit — show prominent halt panel ──────────────
+        statusBar.clear();
+        process.stdout.write('\x07'); // terminal bell
+        const bar = chalk.dim('  ┃  ');
+        const RECOVERY = {
+          GEMINI:  [
+            `All auto-retries exhausted (3 × 65 s) — wait a few minutes, then retry`,
+            `Fall back to stable model:  ${chalk.cyan('GEMINI_MODEL=gemini-2.5-pro npm run control')}`,
+          ],
+          CLAUDE:  [
+            `Wait a few minutes — Claude rate limits reset automatically`,
+            `Switch model:  ${chalk.cyan('CLAUDE_MODEL=claude-haiku-4-5-20251001 npm run control')}`,
+          ],
+          COPILOT: [
+            `Wait a few minutes — Copilot rate limits reset automatically`,
+            `Switch model:  ${chalk.cyan('COPILOT_MODEL=claude-haiku-4.5 npm run control')}`,
+          ],
+        };
+        const steps = RECOVERY[err.agent] || [`Wait and retry`];
+
+        console.log('');
+        console.log(chalk.red.bold(`  ┃  ${err.agent} — USAGE LIMIT REACHED  ·  pipeline stopped`));
+        console.log(chalk.dim('  ┃'));
+        console.log(`${bar}${chalk.yellow(err.message)}`);
+        console.log(chalk.dim('  ┃'));
+        console.log(`${bar}${chalk.bold('What to do:')}`);
+        steps.forEach((s, i) => console.log(`${bar}  ${chalk.dim(`${i + 1}.`)}  ${s}`));
+        console.log('');
+      } else {
+        console.log(chalk.red(`\n  ✗  ${err.message}\n`));
+      }
+    }
+
+    // Smart Navigation: only suggest next step when the action actually ran.
+    // Cancelled actions (returned false/undefined) go straight back to the main menu.
+    const pipelineActions = ['new-feature', 'fix-bug', 'review', 'approve', 'reject', 'deploy'];
+    if (pipelineActions.includes(action) && actionCompleted) {
+      if (getStatus().pipeline_mode === 'auto') {
+        nextAction = null; // Skip prompt, let runAutoPilot handle the next step
+      } else {
+        nextAction = await promptNextStep(getStatus());
+      }
+    } else {
+      await pressEnterToContinue();
+    }
+  }
+}
+
+mainMenu().catch(err => {
+  console.error(chalk.red('\n  Fatal:'), err.message);
+  process.exit(1);
+});