ai-control-center 1.15.2

package/lib/actions/fix-bug.js

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { newFeatureAction } from './new-feature.js';
+import { getLatestQAReport } from '../agents/browser-qa-agent.js';
+import { getWorkflowDir } from '../utils/pipeline.js';
+
+/**
+ * Build bug context from QA report (browser evidence).
+ * Returns null if no QA report exists.
+ */
+function buildQABugContext() {
+  try {
+    const report = getLatestQAReport();
+    if (!report || report.failed.length === 0) return null;
+
+    return report.failed.map(f => ({
+      url:        f.url,
+      errors:     f.errors,
+      screenshot: f.screenshot,
+      warnings:   f.warnings,
+    }));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build bug context from latest fix notes (AI-generated fix summaries).
+ */
+function getLatestFixNotes() {
+  try {
+    const qaDir = resolve(getWorkflowDir(), 'qa-reports');
+    if (!existsSync(qaDir)) return '';
+    const fixFiles = readdirSync(qaDir)
+      .filter(f => f.startsWith('FIX-'))
+      .sort()
+      .reverse();
+    if (fixFiles.length === 0) return '';
+    return readFileSync(resolve(qaDir, fixFiles[0]), 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Save QA evidence to a context file that the bug-fix pipeline can read.
+ */
+function saveQAContext() {
+  const qaContext = buildQABugContext();
+  const fixNotes = getLatestFixNotes();
+  if (!qaContext && !fixNotes) return;
+
+  const contextDir = resolve(getWorkflowDir(), 'qa-reports');
+  if (!existsSync(contextDir)) mkdirSync(contextDir, { recursive: true });
+
+  const contextPath = resolve(contextDir, 'bugfix-context.json');
+  writeFileSync(contextPath, JSON.stringify({
+    qaEvidence: qaContext,
+    previousFixNotes: fixNotes.slice(0, 1000),
+    generatedAt: new Date().toISOString(),
+  }, null, 2));
+}
+
+/**
+ * Fix bugs found by QA.
+ *
+ * When called from the autonomous bugfix loop (fromQA: true), runs
+ * non-interactively using runNewFeature() from action-runner.
+ * When called from the interactive menu, delegates to newFeatureAction()
+ * which shows the mode prompt.
+ *
+ * @param {object} [options]
+ * @param {string} [options.featureId]   - project/feature ID for context
+ * @param {boolean} [options.fromQA]     - true when auto-triggered by browser QA
+ * @param {string} [options.mode]        - 'auto' | 'manual' (default: 'auto' when fromQA)
+ * @param {string} [options.description] - override bug description
+ */
+export async function fixBugAction(options = {}) {
+  // Save QA evidence to context file before running the bug-fix pipeline
+  saveQAContext();
+
+  const { fromQA = false, mode, description } = options;
+
+  // ── Autonomous mode (triggered by browser QA bugfix loop) ───────────
+  if (fromQA) {
+    const { runNewFeature } = await import('../shared/action-runner.js');
+
+    // Build description from QA report if not provided
+    let bugDescription = description;
+    if (!bugDescription) {
+      const qaContext = buildQABugContext();
+      if (qaContext && qaContext.length > 0) {
+        // Group failures by error type for clearer AI instructions
+        const errorGroups = {};
+        for (const f of qaContext) {
+          for (const err of (f.errors || ['Unknown error'])) {
+            const key = err.replace(/https?:\/\/[^\s]+/g, '<url>').slice(0, 80);
+            if (!errorGroups[key]) errorGroups[key] = [];
+            errorGroups[key].push(f.url);
+          }
+        }
+
+        const lines = [];
+        for (const [error, urls] of Object.entries(errorGroups)) {
+          lines.push(`## ${error}`);
+          for (const u of urls.slice(0, 10)) lines.push(`- ${u}`);
+          if (urls.length > 10) lines.push(`- ... and ${urls.length - 10} more`);
+        }
+
+        bugDescription = [
+          `Fix: Browser QA found ${qaContext.length} broken route(s).`,
+          `Read the full QA report at .ai-workflow/qa-reports/bugfix-context.json for screenshots and details.`,
+          ``,
+          `Failures by category:`,
+          ...lines,
+          ``,
+          `Instructions:`,
+          `1. Read the bugfix-context.json for full error details and screenshots`,
+          `2. For "Page appears to be a 404 error" — the route exists in navigation but has no page component. Create the missing page or fix the broken link.`,
+          `3. For console errors — fix the underlying code issue`,
+          `4. For visual regressions — check recent CSS/layout changes`,
+          `5. Run the project tests after fixing to ensure no regressions`,
+        ].join('\n');
+      } else {
+        bugDescription = 'Fix bugs found by Browser QA agent (see .ai-workflow/qa-reports/bugfix-context.json for full details)';
+      }
+    }
+
+    return runNewFeature(bugDescription, mode || 'auto', 'bug', { awaitPipeline: true });
+  }
+
+  // ── Interactive mode (from terminal menu) ───────────────────────────
+  return newFeatureAction('bug');
+}

package/lib/actions/new-feature.js

@@ -0,0 +1,255 @@
+import chalk from 'chalk';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import inquirer from 'inquirer';
+import { resolve } from 'path';
+import { getConfig } from '../config.js';
+import { logActivity, printActivityFooter, printActivityHeader } from '../utils/activity-log.js';
+import { printWarning } from '../utils/display.js';
+import { getLatestFilePath, getRootDir, getStatus, getWorkflowDir, updateStatus } from '../utils/pipeline.js';
+import { isAvailable, runClaude, runCopilot, runGemini } from '../utils/runner.js';
+import { injectSkills } from '../utils/skill-loader.js';
+import { spinCycle, spinner } from '../utils/spinner.js';
+import { reviewAction } from './review.js';
+
+// ─── Load a .claude/skills/*.md file, stripping YAML frontmatter ──────────────
+// Legacy loader — kept for backward compat with project-specific skill names
+function loadSkill(name) {
+  const root      = getRootDir();
+  const skillPath = resolve(root, `.claude/skills/${name}.md`);
+  if (!existsSync(skillPath)) return null;
+  const raw = readFileSync(skillPath, 'utf8');
+  return raw.replace(/^---[\s\S]*?---\n*/m, '').trim();
+}
+
+export async function newFeatureAction(type = 'feature') {
+  const label       = type === 'bug' ? 'Bug Fix' : 'Feature';
+  const placeholder = type === 'bug'
+    ? 'e.g. Fix: Authentication token not refreshing after expiry'
+    : 'e.g. Add user notification system for pipeline events';
+
+  // ── Mode selection (BEFORE pipeline starts) ──────────────────────────────────
+  // rawlist lets user type 1 or 2 + Enter — works on mobile without arrow keys.
+  const { pipelineMode } = await inquirer.prompt([{
+    type:    'rawlist',
+    name:    'pipelineMode',
+    message: 'Pipeline mode:',
+    prefix:  '◆',
+    choices: [
+      { name: 'Auto   — run entire pipeline, notify when ready to deploy', value: 'auto' },
+      { name: 'Manual — step through each stage yourself', value: 'manual' },
+      { name: chalk.dim('Cancel — back to main menu'), value: 'cancel' },
+    ],
+  }]);
+
+  if (pipelineMode === 'cancel') return false;
+
+  const { description } = await inquirer.prompt([{
+    type:     'input',
+    name:     'description',
+    message:  `Describe your ${label.toLowerCase()}:`,
+    suffix:   `\n  ${placeholder}\n  ${chalk.dim('(leave blank to cancel)')}\n  `,
+    validate: v => v.trim().length === 0 || v.trim().length >= 10 || 'Please provide at least 10 characters',
+  }]);
+
+  if (!description.trim()) return false;
+
+  const prefix          = type === 'bug' ? 'Fix: ' : '';
+  const fullDescription = `${prefix}${description.trim()}`;
+
+  printActivityHeader(`PIPELINE — New ${label}`);
+
+  // ── STEP 1: Create inbox file ────────────────────────────────────────────────
+  logActivity('PIPELINE', `Submitting: "${fullDescription}"`);
+
+  spinner.start('Pipeline  ·  Creating feature inbox file...');
+
+  // Create inbox file inline (no external .sh dependency)
+  const _now       = new Date();
+  const _pad       = n => String(n).padStart(2, '0');
+  const _tsStamp   = `${_now.getFullYear()}${_pad(_now.getMonth()+1)}${_pad(_now.getDate())}-${_pad(_now.getHours())}${_pad(_now.getMinutes())}${_pad(_now.getSeconds())}`;
+  const _featureId = `FEATURE-${_tsStamp}`;
+  const _inboxDir  = resolve(getWorkflowDir(), 'inbox');
+  if (!existsSync(_inboxDir)) mkdirSync(_inboxDir, { recursive: true });
+  writeFileSync(resolve(_inboxDir, `${_featureId}.md`), [
+    `# Feature Request: ${_featureId}`,
+    `**Submitted:** ${_now.toLocaleString()}`,
+    `**Status:** INBOX`,
+    ``,
+    `## Description`,
+    fullDescription,
+    ``,
+    `## Notes`,
+    `(Add any additional context, constraints, or business rules here)`,
+    ``,
+  ].join('\n'));
+  const _inboxHistory = [...(getStatus().history || []), { id: _featureId, stage: 'inbox', time: _now.toISOString() }];
+  updateStatus({ current_feature: _featureId, stage: 'inbox', next: 'pm_spec', history: _inboxHistory });
+
+  spinner.stop();
+
+  // Persist the chosen mode and reset the auto-review counter for this feature
+  updateStatus({ pipeline_mode: pipelineMode, auto_review_count: 0 });
+
+  const status      = getStatus();
+  const featureId   = status.current_feature;
+  const workflowDir = getWorkflowDir();
+  const root        = getRootDir();
+
+  logActivity('PIPELINE', `Feature ID: ${featureId}`, 'success');
+  logActivity('PIPELINE', `Inbox file created at: .ai-workflow/inbox/${featureId}.md`);
+
+  // ── STEP 2 + 3a: Gemini PM spec + Claude codebase exploration (parallel) ─────
+  // Gemini writes the PM spec while Claude simultaneously explores the codebase.
+  // This saves ~30-60s — Claude's architecture step then resumes the same session
+  // and already has full codebase context.
+  const geminiAvailable = await isAvailable('gemini');
+  const claudeAvailable = await isAvailable('claude');
+  const geminiMd        = resolve(root, 'GEMINI.md');
+  const inboxFile       = resolve(workflowDir, `inbox/${featureId}.md`);
+  const timestamp       = featureId.replace('FEATURE-', '');
+  const specFile        = resolve(workflowDir, `specs/SPEC-${timestamp}.md`);
+
+  // Gemini PM spec promise
+  const geminiPromise = (geminiAvailable && existsSync(geminiMd))
+    ? (async () => {
+        logActivity('GEMINI', 'Starting PM spec generation...');
+
+        let prompt =
+          `${readFileSync(geminiMd, 'utf8')}\n\n## Feature Request\n${readFileSync(inboxFile, 'utf8')}\n\n` +
+          `Create a complete PM spec with User Stories, Acceptance Criteria, Technical Risks, Dependencies, and Priority for ${(() => { try { return getConfig().name; } catch { return 'this project'; } })()}.`;
+
+        // Inject OpenClaw/project skills for the spec stage
+        prompt = injectSkills(prompt, 'spec');
+
+        const stopCycle = spinCycle('Gemini', [
+          'Analyzing feature requirements...',
+          'Writing user stories and acceptance criteria...',
+          'Identifying technical risks and dependencies...',
+          'Defining priority and effort estimates...',
+          'Finalizing PM spec...',
+        ], 4000, 'cyan');
+
+        await runGemini(prompt, specFile);
+
+        stopCycle();
+        spinner.succeed(`PM spec written → specs/SPEC-${timestamp}.md`);
+        updateStatus({ stage: 'spec_complete', next: 'architect' });
+        logActivity('GEMINI', `Spec ready: .ai-workflow/specs/SPEC-${timestamp}.md`, 'success');
+      })()
+    : (logActivity('GEMINI', 'CLI not found — Claude will handle PM spec', 'warn'), Promise.resolve());
+
+  // Claude codebase exploration promise (runs while Gemini writes spec)
+  const claudeExplorePromise = claudeAvailable
+    ? runClaude(
+        `Explore the ${(() => { try { return getConfig().name; } catch { return 'project'; } })()} codebase to prepare for architecture design.\n\n` +
+        `1. List key source files and their purpose\n` +
+        `2. Identify existing patterns and reusable components\n` +
+        `3. Note any partial or incomplete implementations relevant to the upcoming feature\n\n` +
+        `Summarize your findings briefly. Architecture design will follow in the next step.`,
+        { featureId }
+      ).catch(err => logActivity('CLAUDE', `Codebase exploration skipped: ${err.message}`, 'warn'))
+    : Promise.resolve();
+
+  if (claudeAvailable) {
+    logActivity('PIPELINE', 'Running Gemini PM spec + Claude codebase exploration in parallel...');
+  }
+
+  await Promise.all([geminiPromise, claudeExplorePromise]);
+
+  // ── STEP 3: Claude as Architect — resumes session with codebase knowledge ─────
+  if (claudeAvailable) {
+    logActivity('CLAUDE', 'Starting architecture design (resuming codebase exploration session)...');
+
+    const specContent    = existsSync(specFile) ? readFileSync(specFile, 'utf8') : fullDescription;
+    const architectSkill = loadSkill('xconn-architect');
+
+    // Build architecture prompt — prefer OpenClaw/project skill, fall back to legacy or inline
+    let architectPrompt;
+    if (architectSkill) {
+      architectPrompt = architectSkill.replace(/\{timestamp\}/g, timestamp) + `\n\n## Feature Spec\n${specContent}`;
+    } else {
+      architectPrompt = `${(() => { try { return getConfig().ai.system + '\n\n'; } catch { return ''; } })()}You are the System Architect. Read this feature spec carefully. Your codebase exploration from the previous step gives you full context.
+
+Your job:
+1. Write a detailed architecture doc to: .ai-workflow/architecture/ARCH-${timestamp}.md
+   Include: Data flow, new classes/components, any schema changes needed
+2. Write step-by-step implementation tasks to: .ai-workflow/tasks/TASKS-${timestamp}.md
+   Each task must reference exact file paths and class/function names
+
+## Feature Spec
+${specContent}`;
+    }
+    // Inject OpenClaw/project skills for the architecture stage
+    architectPrompt = injectSkills(architectPrompt, 'arch');
+
+    const stopCycle = spinCycle('Claude', [
+      'Resuming codebase exploration context...',
+      'Designing Apex architecture...',
+      'Planning LWC components...',
+      'Writing implementation tasks for Copilot...',
+      'Reviewing governor limit considerations...',
+      'Finalizing architecture document...',
+    ], 5000, 'magenta');
+
+    await runClaude(architectPrompt, { featureId });
+
+    stopCycle();
+    spinner.succeed(`Architecture + Tasks written`);
+
+    updateStatus({ stage: 'arch_complete', next: 'copilot_implement' });
+    logActivity('CLAUDE', `Architecture ready: .ai-workflow/architecture/ARCH-${timestamp}.md`, 'success');
+    logActivity('CLAUDE', `Tasks ready:        .ai-workflow/tasks/TASKS-${timestamp}.md`, 'success');
+  } else {
+    logActivity('CLAUDE', 'CLI not found — paste into Claude Code:', 'warn');
+    printWarning(`"Read .ai-workflow/specs/SPEC-${timestamp}.md and create architecture + tasks"`);
+  }
+
+  // ── STEP 4: Copilot implements the tasks ──────────────────────────────────────
+  // Claude's role ends at architecture. Copilot codes every task.
+  const tasksFile = getLatestFilePath('tasks');
+  if (tasksFile) {
+    const relPath     = tasksFile.replace(root + '/', '');
+    const archRelPath = relPath.replace('tasks/TASKS', 'architecture/ARCH');
+
+    logActivity('COPILOT', 'Starting implementation...');
+    logActivity('COPILOT', `Tasks: ${relPath}`);
+    logActivity('COPILOT', `Arch:  ${archRelPath}`);
+
+    const copilotSkill  = loadSkill('xconn-copilot-implement');
+    let copilotPrompt =
+      `Read ${relPath} and implement every task listed there.\n` +
+      `Follow the architecture at ${archRelPath}.\n\n` +
+      (copilotSkill || `Implement every task in the task list following the architecture document. Make minimal, precise changes to existing files. Do not break existing functionality.`);
+    // Inject OpenClaw/project skills for the implementation stage
+    copilotPrompt = injectSkills(copilotPrompt, 'impl');
+
+    const stopImpl = spinCycle('Copilot', [
+      'Reading architecture and task list...',
+      'Implementing Apex classes...',
+      'Writing test classes...',
+      'Implementing LWC components...',
+      'Applying governor limit safeguards...',
+      'Finalizing implementation...',
+    ], 6000, 'blue');
+
+    await runCopilot(copilotPrompt, { featureId });
+
+    stopImpl();
+    spinner.succeed('Copilot implementation complete');
+
+    updateStatus({ stage: 'implementation_complete', next: 'review' });
+    logActivity('COPILOT', 'All tasks implemented', 'success');
+  }
+
+  printActivityFooter();
+
+  // ── Auto mode: trigger review immediately; Manual mode: menu handles it ──────
+  if (pipelineMode === 'auto') {
+    logActivity('PIPELINE', 'Auto mode — starting code review...', 'info');
+    await reviewAction();
+  } else {
+    logActivity('PIPELINE', 'Manual mode — select Review Code from the menu when ready.', 'info');
+  }
+
+  return true;
+}