ai-control-center 1.15.2

package/lib/integrations/codex-runner.js

@@ -0,0 +1,128 @@
+/**
+ * OpenAI Codex CLI Integration.
+ *
+ * Lightweight wrapper for the `codex` CLI tool.
+ * Handles availability checks, config, and command building.
+ * Actual execution is deferred to the main runner.
+ */
+
+import { existsSync } from 'fs';
+import { execSync, spawn } from 'child_process';
+
+/** Default configuration for the Codex CLI. */
+export const CODEX_DEFAULTS = {
+  model: 'codex-mini',
+  maxTokens: 8000,
+  timeout: 300_000,
+};
+
+/**
+ * Check whether the `codex` CLI is installed and accessible.
+ */
+export function isCodexAvailable() {
+  try {
+    execSync('which codex', { stdio: 'ignore' });
+    return true;
+  } catch {
+    try {
+      execSync('codex --version', { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+/**
+ * Resolve Codex configuration from environment variables and defaults.
+ */
+export function getCodexConfig() {
+  return {
+    model:     process.env.CODEX_MODEL     || CODEX_DEFAULTS.model,
+    maxTokens: Number(process.env.CODEX_MAX_TOKENS) || CODEX_DEFAULTS.maxTokens,
+    timeout:   Number(process.env.CODEX_TIMEOUT)    || CODEX_DEFAULTS.timeout,
+    available: isCodexAvailable(),
+  };
+}
+
+/**
+ * Build the shell command and arguments for invoking the Codex CLI.
+ *
+ * @param {string} prompt   – the prompt text
+ * @param {object} [options] – overrides for model, maxTokens, etc.
+ * @returns {{ command: string, args: string[] }}
+ */
+export function buildCodexCommand(prompt, options = {}) {
+  const model = options.model || CODEX_DEFAULTS.model;
+  const safePrompt = prompt.replace(/"/g, '\\"');
+
+  const args = [
+    '--model', model,
+    '--quiet',
+    `"${safePrompt}"`,
+  ];
+
+  if (options.maxTokens) {
+    args.unshift('--max-tokens', String(options.maxTokens));
+  }
+
+  return {
+    command: `codex ${args.join(' ')}`,
+    args,
+  };
+}
+
+/**
+ * Execute the Codex CLI and return its output.
+ *
+ * @param {string} prompt   – the prompt text
+ * @param {object} [options] – { model, maxTokens, timeout, cwd }
+ * @returns {Promise<{ output: string, exitCode: number }>}
+ */
+export function runCodex(prompt, options = {}) {
+  if (!isCodexAvailable()) {
+    return Promise.reject(new Error('Codex CLI is not installed or not in PATH'));
+  }
+
+  const { command } = buildCodexCommand(prompt, options);
+  const timeout = options.timeout || CODEX_DEFAULTS.timeout;
+  const cwd = options.cwd || process.cwd();
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('sh', ['-c', command], {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      killed = true;
+      proc.kill('SIGTERM');
+    }, timeout);
+
+    proc.stdout.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    proc.on('error', (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Codex process error: ${err.message}`));
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      if (killed) {
+        reject(new Error(`Codex timed out after ${timeout}ms`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`Codex exited with code ${code}: ${stderr.trim().slice(0, 2000)}`));
+        return;
+      }
+      resolve({ output: stdout.trim(), exitCode: code });
+    });
+  });
+}

package/lib/integrations/github-actions.js

@@ -0,0 +1,248 @@
+/**
+ * GitHub Actions Integration — workflow generation and PR formatting.
+ *
+ * Generates GitHub Actions workflow YAML for AICC integration,
+ * formats pipeline results as PR comments and Check Run payloads.
+ */
+import { getConfig } from '../config.js';
+
+// ─── Constants ─────────────────────────────────────────────────────────────────
+
+export const GITHUB_ACTION_VERSION = 'v1';
+
+// ─── Workflow YAML generation ──────────────────────────────────────────────────
+
+/**
+ * Generate a GitHub Actions workflow YAML string for AICC integration.
+ *
+ * @param {object} [options]
+ * @param {'pr'|'label'|'push'} [options.triggerOn='pr'] — when to trigger
+ * @param {boolean} [options.reviewOnPR=true] — run AI review on PRs
+ * @param {boolean} [options.deployOnMerge=false] — deploy on merge to main
+ * @returns {string} YAML content
+ */
+export function generateWorkflowYaml(options = {}) {
+  const { triggerOn = 'pr', reviewOnPR = true, deployOnMerge = false } = options;
+
+  const onTrigger = buildTriggerSection(triggerOn);
+  const jobs = [];
+
+  if (reviewOnPR) {
+    jobs.push(buildReviewJob(triggerOn));
+  }
+
+  if (deployOnMerge) {
+    jobs.push(buildDeployJob());
+  }
+
+  // Always include workflow_dispatch for manual actions
+  const yaml = [
+    `name: AI Control Center Pipeline`,
+    ``,
+    `on:`,
+    ...onTrigger,
+    `  workflow_dispatch:`,
+    `    inputs:`,
+    `      action:`,
+    `        description: 'Action to perform'`,
+    `        required: true`,
+    `        type: choice`,
+    `        options:`,
+    `          - review`,
+    `          - feature`,
+    `          - deploy`,
+    ``,
+    `jobs:`,
+    ...jobs,
+  ];
+
+  return yaml.join('\n') + '\n';
+}
+
+/** Build the 'on' trigger section based on trigger type */
+function buildTriggerSection(triggerOn) {
+  switch (triggerOn) {
+    case 'label':
+      return [
+        `  pull_request:`,
+        `    types: [labeled]`,
+      ];
+    case 'push':
+      return [
+        `  push:`,
+        `    branches: [main, master]`,
+      ];
+    case 'pr':
+    default:
+      return [
+        `  pull_request:`,
+        `    types: [opened, synchronize]`,
+      ];
+  }
+}
+
+/** Build the AI review job */
+function buildReviewJob(triggerOn) {
+  const condition = triggerOn === 'label'
+    ? `    if: github.event.label.name == 'ai-review'`
+    : '';
+
+  const lines = [
+    `  ai-review:`,
+    `    runs-on: ubuntu-latest`,
+  ];
+
+  if (condition) lines.push(condition);
+
+  lines.push(
+    `    steps:`,
+    `      - uses: actions/checkout@v4`,
+    `      - uses: actions/setup-node@v4`,
+    `        with:`,
+    `          node-version: '20'`,
+    `      - run: npm install -g ai-control-center`,
+    `      - run: aicc review`,
+    `        env:`,
+    `          GEMINI_API_KEY: \${{ secrets.GEMINI_API_KEY }}`,
+    `      - name: Post Review Comment`,
+    `        if: github.event_name == 'pull_request'`,
+    `        uses: actions/github-script@v7`,
+    `        with:`,
+    `          script: |`,
+    `            const fs = require('fs');`,
+    `            const review = fs.readFileSync('.ai-workflow/reviews/latest.md', 'utf8');`,
+    `            github.rest.issues.createComment({`,
+    `              issue_number: context.issue.number,`,
+    `              owner: context.repo.owner,`,
+    `              repo: context.repo.repo,`,
+    `              body: '## 🤖 AI Code Review\\n\\n' + review`,
+    `            });`,
+  );
+
+  return lines.join('\n');
+}
+
+/** Build the deploy-on-merge job */
+function buildDeployJob() {
+  return [
+    `  ai-deploy:`,
+    `    runs-on: ubuntu-latest`,
+    `    if: github.event_name == 'push' && github.ref == 'refs/heads/main'`,
+    `    steps:`,
+    `      - uses: actions/checkout@v4`,
+    `      - uses: actions/setup-node@v4`,
+    `        with:`,
+    `          node-version: '20'`,
+    `      - run: npm install -g ai-control-center`,
+    `      - run: aicc deploy`,
+    `        env:`,
+    `          GEMINI_API_KEY: \${{ secrets.GEMINI_API_KEY }}`,
+  ].join('\n');
+}
+
+// ─── PR Comment formatting ─────────────────────────────────────────────────────
+
+/**
+ * Format a pipeline result as a GitHub PR comment (markdown).
+ *
+ * @param {object} result — pipeline result
+ * @param {string} [result.stage] — pipeline stage
+ * @param {string} [result.status] — pass/fail
+ * @param {string} [result.summary] — human-readable summary
+ * @param {Array} [result.issues] — list of issues found
+ * @param {string} [result.review] — full review text
+ * @returns {string} Markdown-formatted PR comment
+ */
+export function formatPRComment(result) {
+  if (!result) return '## 🤖 AI Control Center\n\nNo results available.';
+
+  const icon = result.status === 'pass' ? '✅' : result.status === 'fail' ? '❌' : '🔄';
+  const lines = [
+    `## 🤖 AI Control Center — ${result.stage || 'Pipeline'} ${icon}`,
+    '',
+  ];
+
+  if (result.summary) {
+    lines.push(result.summary, '');
+  }
+
+  if (result.issues?.length) {
+    lines.push('### Issues Found', '');
+    for (const issue of result.issues) {
+      const severity = issue.severity === 'error' ? '🔴' : issue.severity === 'warning' ? '🟡' : '🔵';
+      lines.push(`- ${severity} **${issue.file || 'General'}**${issue.line ? ` (L${issue.line})` : ''}: ${issue.message}`);
+    }
+    lines.push('');
+  }
+
+  if (result.review) {
+    lines.push('<details>', '<summary>📝 Full Review</summary>', '', result.review, '', '</details>');
+  }
+
+  lines.push('', `---`, `*Generated by AI Control Center ${GITHUB_ACTION_VERSION}*`);
+  return lines.join('\n');
+}
+
+// ─── Check Run formatting ──────────────────────────────────────────────────────
+
+/**
+ * Format a pipeline result as a GitHub Check Run payload.
+ *
+ * @param {object} result
+ * @param {string} [result.stage] — pipeline stage
+ * @param {string} [result.status] — pass/fail
+ * @param {string} [result.summary] — summary text
+ * @param {Array} [result.annotations] — code annotations [{path, startLine, endLine, level, message}]
+ * @returns {object} GitHub Check Run API payload
+ */
+export function formatCheckRun(result) {
+  if (!result) {
+    return {
+      name: 'AI Control Center',
+      status: 'completed',
+      conclusion: 'neutral',
+      output: {
+        title: 'AI Control Center',
+        summary: 'No results available',
+      },
+    };
+  }
+
+  const conclusion = result.status === 'pass' ? 'success'
+    : result.status === 'fail' ? 'failure'
+    : 'neutral';
+
+  const payload = {
+    name: `AI Control Center — ${result.stage || 'Pipeline'}`,
+    status: 'completed',
+    conclusion,
+    output: {
+      title: `${result.stage || 'Pipeline'} ${result.status === 'pass' ? '✅' : '❌'}`,
+      summary: result.summary || 'Pipeline check completed',
+    },
+  };
+
+  if (result.annotations?.length) {
+    payload.output.annotations = result.annotations.map(a => ({
+      path: a.path,
+      start_line: a.startLine || a.start_line || 1,
+      end_line: a.endLine || a.end_line || a.startLine || a.start_line || 1,
+      annotation_level: a.level === 'error' ? 'failure' : a.level === 'warning' ? 'warning' : 'notice',
+      message: a.message,
+    }));
+  }
+
+  return payload;
+}
+
+// ─── Default template ──────────────────────────────────────────────────────────
+
+/**
+ * Returns the default workflow template as a string.
+ * This is the recommended starting point for integrating AICC with GitHub Actions.
+ *
+ * @returns {string} YAML workflow content
+ */
+export function getGitHubActionTemplate() {
+  return generateWorkflowYaml({ triggerOn: 'pr', reviewOnPR: true, deployOnMerge: false });
+}

package/lib/integrations/github-reporter.js

@@ -0,0 +1,229 @@
+/**
+ * GitHub Reporter — Creates GitHub Issues and PR comments with screenshots.
+ *
+ * Requires:
+ *   config.github.token    — Personal Access Token (repo scope)
+ *   config.github.owner    — Repository owner (username or org)
+ *   config.github.repo     — Repository name
+ *   config.github.enabled  — true to enable
+ *
+ * Features:
+ * - Creates one GitHub Issue per failed URL (with screenshot embedded)
+ * - Adds labels: 'ai-qa', 'bug', severity label
+ * - Auto-closes issues when QA verifies the bug is fixed
+ * - Tracks issue numbers in .ai-workflow/qa-reports/github-issues.json
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { getWorkflowDir } from '../utils/pipeline.js';
+import { logActivity } from '../utils/activity-log.js';
+
+// Lazy import Octokit to avoid hard dependency crash if not installed
+async function getOctokit(token) {
+  const { Octokit } = await import('@octokit/rest');
+  return new Octokit({ auth: token });
+}
+
+const ISSUES_TRACKING_FILE = () => resolve(getWorkflowDir(), 'qa-reports/github-issues.json');
+
+function loadIssueTracking() {
+  const file = ISSUES_TRACKING_FILE();
+  if (!existsSync(file)) return {};
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return {}; }
+}
+
+function saveIssueTracking(data) {
+  writeFileSync(ISSUES_TRACKING_FILE(), JSON.stringify(data, null, 2));
+}
+
+function slugKey(url) {
+  return url.replace(/https?:\/\//, '').replace(/[^a-z0-9]/gi, '_').slice(0, 60);
+}
+
+function buildIssueBody(bug, screenshotBase64) {
+  const screenshotSection = screenshotBase64
+    ? `\n### Screenshot\n![screenshot](data:image/png;base64,${screenshotBase64.slice(0, 2000)}...)\n`
+    : '';
+
+  return `## Bug Report (Auto-generated by AI QA Agent)
+
+**URL:** \`${bug.url}\`
+**Found at:** ${new Date().toISOString()}
+**Severity:** ${bug.errors.length > 0 ? 'Critical' : 'Warning'}
+
+### Errors
+${bug.errors.map(e => `- ${e}`).join('\n') || 'None'}
+
+### Warnings
+${bug.warnings?.map(w => `- ${w}`).join('\n') || 'None'}
+${screenshotSection}
+---
+*Created automatically by [AI Control Center](https://www.npmjs.com/package/ai-control-center). Close this issue when the bug is verified fixed.*
+`;
+}
+
+/**
+ * Report all failed QA tests as GitHub Issues.
+ */
+export async function reportBugsToGitHub(qaReport, config) {
+  if (!config.github?.enabled || !config.github?.token) {
+    logActivity('GITHUB', 'GitHub reporting disabled or no token', 'warn');
+    return;
+  }
+
+  const octokit  = await getOctokit(config.github.token);
+  const { owner, repo } = config.github;
+  const tracking = loadIssueTracking();
+
+  let store = null;
+  try {
+    const { ScreenshotStore } = await import('./screenshot-store.js');
+    store = new ScreenshotStore(resolve(getWorkflowDir(), 'screenshots'));
+  } catch { /* screenshot store not available */ }
+
+  for (const bug of qaReport.failed) {
+    const key = slugKey(bug.url);
+
+    // Skip if issue already open for this URL
+    if (tracking[key]?.open) {
+      logActivity('GITHUB', `Issue already open for ${bug.url} (#${tracking[key].number})`, 'info');
+      continue;
+    }
+
+    try {
+      const screenshotBase64 = (bug.screenshot && store) ? store.getBase64(bug.screenshot) : null;
+      const body = buildIssueBody(bug, screenshotBase64);
+
+      const { data: issue } = await octokit.issues.create({
+        owner,
+        repo,
+        title: `[AI-QA] Bug on ${new URL(bug.url).pathname}`,
+        body,
+        labels: ['ai-qa', 'bug', bug.errors.length > 0 ? 'critical' : 'warning'],
+      });
+
+      tracking[key] = { number: issue.number, url: bug.url, open: true, createdAt: new Date().toISOString() };
+      saveIssueTracking(tracking);
+
+      logActivity('GITHUB', `Created issue #${issue.number} for ${bug.url}`, 'success');
+
+    } catch (err) {
+      logActivity('GITHUB', `Failed to create issue for ${bug.url}: ${err.message}`, 'error');
+    }
+  }
+}
+
+/**
+ * Close GitHub Issues for bugs that are now passing in QA.
+ */
+export async function closeResolvedIssues(qaReport, config) {
+  if (!config.github?.enabled || !config.github?.token) return;
+
+  const octokit  = await getOctokit(config.github.token);
+  const { owner, repo } = config.github;
+  const tracking = loadIssueTracking();
+
+  const passingUrls = new Set(qaReport.passed.map(p => p.url));
+
+  for (const [key, issueInfo] of Object.entries(tracking)) {
+    if (!issueInfo.open) continue;
+    if (!passingUrls.has(issueInfo.url)) continue;
+
+    try {
+      await octokit.issues.createComment({
+        owner, repo, issue_number: issueInfo.number,
+        body: `This bug has been verified fixed by the AI QA Agent.\n\nQA run: ${new Date().toISOString()}`,
+      });
+      await octokit.issues.update({
+        owner, repo, issue_number: issueInfo.number, state: 'closed',
+      });
+
+      tracking[key].open = false;
+      tracking[key].closedAt = new Date().toISOString();
+      saveIssueTracking(tracking);
+
+      logActivity('GITHUB', `Closed issue #${issueInfo.number} — bug verified fixed`, 'success');
+    } catch (err) {
+      logActivity('GITHUB', `Failed to close issue #${issueInfo.number}: ${err.message}`, 'error');
+    }
+  }
+}
+
+/**
+ * Upload screenshot to GitHub repo and return markdown image link.
+ * Uploads to: .ai-qa-screenshots/{name}.png in the repo.
+ */
+export async function uploadScreenshotToGitHub(octokit, owner, repo, screenshotPath, name) {
+  const content = readFileSync(screenshotPath).toString('base64');
+  const path = `.ai-qa-screenshots/${name}.png`;
+
+  try {
+    // Check if file exists (to get SHA for update)
+    let sha;
+    try {
+      const { data } = await octokit.repos.getContent({ owner, repo, path });
+      sha = data.sha;
+    } catch { /* file doesn't exist yet */ }
+
+    await octokit.repos.createOrUpdateFileContents({
+      owner, repo, path,
+      message: `[AI-QA] Screenshot: ${name}`,
+      content,
+      sha,
+      committer: {
+        name: 'AI QA Agent',
+        email: 'ai-qa@aicc.local',
+      },
+    });
+
+    return `https://raw.githubusercontent.com/${owner}/${repo}/main/${path}`;
+  } catch (err) {
+    logActivity('GITHUB', `Screenshot upload failed: ${err.message}`, 'warn');
+    return null;
+  }
+}
+
+/**
+ * Add QA summary as PR comment (runs after deploy from a branch).
+ */
+export async function commentOnPR(qaReport, config) {
+  if (!config.github?.enabled || !config.github?.token) return;
+
+  const octokit = await getOctokit(config.github.token);
+  const { owner, repo } = config.github;
+
+  try {
+    // Find open PRs
+    const { data: prs } = await octokit.pulls.list({ owner, repo, state: 'open', per_page: 5 });
+    if (prs.length === 0) return;
+
+    const latestPR = prs[0]; // Most recent PR
+    const { passRate, totalRoutes, passed, failed } = qaReport.summary || {};
+
+    const icon = (failed || 0) === 0 ? '✅' : '❌';
+    const body = `${icon} **AI QA Report**
+
+| Metric | Value |
+|--------|-------|
+| Routes tested | ${totalRoutes || 0} |
+| Passed | ${passed || 0} |
+| Failed | ${failed || 0} |
+| Pass rate | ${passRate || 0}% |
+
+${(failed || 0) > 0 && qaReport.failed ? `### Failed Pages\n${qaReport.failed.map(f => `- \`${f.url}\`: ${f.errors?.[0] || 'unknown error'}`).join('\n')}` : ''}
+
+---
+*Generated by AI Control Center QA Agent*`;
+
+    await octokit.issues.createComment({
+      owner, repo,
+      issue_number: latestPR.number,
+      body,
+    });
+
+    logActivity('GITHUB', `Commented on PR #${latestPR.number} with QA results`, 'success');
+  } catch (err) {
+    logActivity('GITHUB', `Failed to comment on PR: ${err.message}`, 'error');
+  }
+}

package/lib/integrations/screenshot-store.js

@@ -0,0 +1,102 @@
+/**
+ * Screenshot Store — manages screenshot capture, storage, and comparison.
+ *
+ * Handles:
+ * - Capturing full-page screenshots via Playwright page object
+ * - Storing baselines (first-run reference images)
+ * - Comparing new screenshots against baselines (pixel diff)
+ * - Returning structured metadata about each screenshot
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { PNG } from 'pngjs';
+import pixelmatch from 'pixelmatch';
+
+export class ScreenshotStore {
+  constructor(baseDir) {
+    this.baseDir     = baseDir;
+    this.baselineDir = join(baseDir, 'baselines');
+    this.diffDir     = join(baseDir, 'diffs');
+    this.currentDir  = join(baseDir, 'current');
+    for (const dir of [this.baselineDir, this.diffDir, this.currentDir]) {
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Capture a screenshot of the current page.
+   * @param {import('playwright').Page} page - Playwright page object
+   * @param {string} name - Slug name for the screenshot
+   * @param {object} options - { baseline: true } to force as baseline
+   * @returns {object} { name, path, baseline, isBaseline, timestamp }
+   */
+  async capture(page, name, options = {}) {
+    const timestamp   = Date.now();
+    const filename    = `${name}.png`;
+    const currentPath = join(this.currentDir, filename);
+    const baselinePath = join(this.baselineDir, filename);
+
+    await page.screenshot({ path: currentPath, fullPage: true });
+
+    const isFirstRun = !existsSync(baselinePath);
+    if (isFirstRun || options.baseline) {
+      const data = readFileSync(currentPath);
+      writeFileSync(baselinePath, data);
+    }
+
+    return {
+      name,
+      path:       currentPath,
+      baseline:   baselinePath,
+      isBaseline: isFirstRun || !!options.baseline,
+      timestamp,
+    };
+  }
+
+  /**
+   * Compare current screenshot with baseline.
+   * @param {object} shotMeta - result from capture()
+   * @param {string} name - slug name
+   * @returns {boolean} true if visual regression detected (diff > threshold)
+   */
+  async compareWithBaseline(shotMeta, name) {
+    const baselinePath = join(this.baselineDir, `${name}.png`);
+    const currentPath  = shotMeta.path || join(this.currentDir, `${name}.png`);
+
+    if (!existsSync(baselinePath) || !existsSync(currentPath)) return false;
+    if (shotMeta.isBaseline) return false;
+
+    try {
+      const img1 = PNG.sync.read(readFileSync(baselinePath));
+      const img2 = PNG.sync.read(readFileSync(currentPath));
+
+      if (img1.width !== img2.width || img1.height !== img2.height) {
+        return true;
+      }
+
+      const diff    = new PNG({ width: img1.width, height: img1.height });
+      const numDiff = pixelmatch(img1.data, img2.data, diff.data, img1.width, img1.height, { threshold: 0.1 });
+      const totalPx = img1.width * img1.height;
+      const diffPct = numDiff / totalPx;
+
+      if (diffPct > 0.02) {
+        const diffPath = join(this.diffDir, `${name}_diff.png`);
+        writeFileSync(diffPath, PNG.sync.write(diff));
+        return true;
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get base64 encoded screenshot for embedding in GitHub issues.
+   */
+  getBase64(shotPath) {
+    if (!existsSync(shotPath)) return null;
+    return readFileSync(shotPath).toString('base64');
+  }
+}