qai-cli 3.0.0

package/src/providers/index.js

@@ -0,0 +1,132 @@
+const AnthropicProvider = require('./anthropic');
+const OpenAIProvider = require('./openai');
+const GeminiProvider = require('./gemini');
+const OllamaProvider = require('./ollama');
+
+const PROVIDERS = {
+  anthropic: AnthropicProvider,
+  openai: OpenAIProvider,
+  codex: OpenAIProvider, // Codex uses OpenAI API
+  gemini: GeminiProvider,
+  ollama: OllamaProvider,
+};
+
+/**
+ * Auto-detect provider from environment variables
+ * Supports both standard env vars (ANTHROPIC_API_KEY) and GitHub Actions format (INPUT_ANTHROPIC_API_KEY)
+ * @returns {{ provider: string, apiKey: string, options: Object } | null}
+ */
+function detectProvider() {
+  const env = process.env;
+
+  // Check for explicit provider + api_key (both formats)
+  const provider = env.PROVIDER || env.INPUT_PROVIDER;
+  const apiKey = env.API_KEY || env.INPUT_API_KEY;
+  if (provider && apiKey) {
+    return {
+      provider: provider.toLowerCase(),
+      apiKey: apiKey,
+      options: {},
+    };
+  }
+
+  // Check for provider-specific keys (standard format first, then INPUT_ format)
+  const anthropicKey = env.ANTHROPIC_API_KEY || env.INPUT_ANTHROPIC_API_KEY;
+  if (anthropicKey) {
+    return {
+      provider: 'anthropic',
+      apiKey: anthropicKey,
+      options: {},
+    };
+  }
+
+  const openaiKey = env.OPENAI_API_KEY || env.INPUT_OPENAI_API_KEY;
+  if (openaiKey) {
+    return {
+      provider: 'openai',
+      apiKey: openaiKey,
+      options: {},
+    };
+  }
+
+  const codexKey = env.CODEX_API_KEY || env.INPUT_CODEX_API_KEY;
+  if (codexKey) {
+    return {
+      provider: 'codex',
+      apiKey: codexKey,
+      options: { model: 'codex-mini-latest' },
+    };
+  }
+
+  const geminiKey = env.GEMINI_API_KEY || env.INPUT_GEMINI_API_KEY;
+  if (geminiKey) {
+    return {
+      provider: 'gemini',
+      apiKey: geminiKey,
+      options: {},
+    };
+  }
+
+  // Ollama doesn't need an API key
+  if (provider === 'ollama') {
+    return {
+      provider: 'ollama',
+      apiKey: null,
+      options: {
+        baseUrl: env.OLLAMA_BASE_URL || env.INPUT_OLLAMA_BASE_URL || 'http://localhost:11434',
+        model: env.OLLAMA_MODEL || env.INPUT_OLLAMA_MODEL || 'llava',
+      },
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Create a provider instance
+ * @param {string} providerName - Provider name
+ * @param {string} apiKey - API key
+ * @param {Object} options - Provider options
+ * @returns {BaseProvider}
+ */
+function createProvider(providerName, apiKey, options = {}) {
+  const ProviderClass = PROVIDERS[providerName.toLowerCase()];
+
+  if (!ProviderClass) {
+    throw new Error(
+      `Unknown provider: ${providerName}. Supported: ${Object.keys(PROVIDERS).join(', ')}`,
+    );
+  }
+
+  return new ProviderClass(apiKey, options);
+}
+
+/**
+ * Get provider from environment (auto-detect or explicit)
+ * @returns {BaseProvider}
+ */
+function getProvider() {
+  const detected = detectProvider();
+
+  if (!detected) {
+    throw new Error(
+      'No API key provided. Set one of: ' +
+        'ANTHROPIC_API_KEY, OPENAI_API_KEY, CODEX_API_KEY, GEMINI_API_KEY, ' +
+        'or PROVIDER with API_KEY',
+    );
+  }
+
+  console.log(`Using provider: ${detected.provider}`);
+  return createProvider(detected.provider, detected.apiKey, detected.options);
+}
+
+module.exports = {
+  PROVIDERS,
+  detectProvider,
+  createProvider,
+  getProvider,
+  AnthropicProvider,
+  OpenAIProvider,
+  GeminiProvider,
+  OllamaProvider,
+};

package/src/providers/ollama.js

@@ -0,0 +1,49 @@
+const BaseProvider = require('./base');
+
+class OllamaProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
+    this.baseUrl = options.baseUrl || 'http://localhost:11434';
+    this.model = options.model || 'llava';
+  }
+
+  async analyze(captureData, options = {}) {
+    const prompt = this.buildPrompt(captureData, options);
+
+    // Ollama expects images as base64 strings in the images array
+    const images = captureData.screenshots.map((s) => s.buffer.toString('base64'));
+
+    // Build the full prompt with screenshot descriptions
+    let fullPrompt = '';
+    for (const screenshot of captureData.screenshots) {
+      const { viewport, width, height } = screenshot;
+      fullPrompt += `[Screenshot: ${viewport} - ${width}x${height}]\n`;
+    }
+    fullPrompt += '\n' + prompt;
+
+    const response = await fetch(`${this.baseUrl}/api/generate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: this.model,
+        prompt: fullPrompt,
+        images,
+        stream: false,
+        options: {
+          temperature: 0.1,
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Ollama request failed: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return this.parseResponse(data.response || '');
+  }
+}
+
+module.exports = OllamaProvider;

package/src/providers/openai.js

@@ -0,0 +1,54 @@
+const OpenAI = require('openai');
+const BaseProvider = require('./base');
+
+class OpenAIProvider extends BaseProvider {
+  constructor(apiKey, options = {}) {
+    super(apiKey, options);
+    this.client = new OpenAI({ apiKey });
+    this.model = options.model || 'gpt-4o';
+  }
+
+  async analyze(captureData, options = {}) {
+    const prompt = this.buildPrompt(captureData, options);
+
+    // Build content array with images
+    const content = [];
+
+    // Add screenshots as images
+    for (const screenshot of captureData.screenshots) {
+      content.push({
+        type: 'image_url',
+        image_url: {
+          url: `data:image/png;base64,${screenshot.buffer.toString('base64')}`,
+          detail: 'high',
+        },
+      });
+      content.push({
+        type: 'text',
+        text: `[Screenshot: ${screenshot.viewport} - ${screenshot.width}x${screenshot.height}]`,
+      });
+    }
+
+    // Add the analysis prompt
+    content.push({
+      type: 'text',
+      text: prompt,
+    });
+
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      max_tokens: 4096,
+      messages: [
+        {
+          role: 'user',
+          content,
+        },
+      ],
+    });
+
+    const responseText = response.choices[0]?.message?.content || '';
+    return this.parseResponse(responseText);
+  }
+}
+
+module.exports = OpenAIProvider;

package/src/types.d.ts

@@ -0,0 +1,148 @@
+import type { Page, TestInfo } from '@playwright/test';
+
+export interface AnalysisOptions {
+  /** Viewports to test (default: ['desktop', 'mobile']) */
+  viewports?: ('mobile' | 'tablet' | 'desktop')[];
+  /** Focus area for analysis */
+  focus?: 'all' | 'accessibility' | 'performance' | 'forms' | 'visual';
+  /** LLM provider to use */
+  provider?: 'anthropic' | 'openai' | 'gemini' | 'ollama' | 'codex';
+  /** API key (uses env var if not provided) */
+  apiKey?: string;
+}
+
+export interface Bug {
+  /** Bug title */
+  title: string;
+  /** Detailed description */
+  description: string;
+  /** Severity level */
+  severity: 'critical' | 'high' | 'medium' | 'low';
+  /** Bug category */
+  category: string;
+  /** Viewport where bug was found */
+  viewport?: string;
+  /** How to fix the bug */
+  recommendation?: string;
+}
+
+export interface Screenshot {
+  /** Screenshot name (e.g., "desktop-1920x1080") */
+  name: string;
+  /** Viewport name */
+  viewport: string;
+  /** Viewport width */
+  width: number;
+  /** Viewport height */
+  height: number;
+  /** Raw screenshot buffer */
+  buffer: Buffer;
+  /** Base64 encoded screenshot */
+  base64: string;
+}
+
+export interface NetworkError {
+  /** Request URL */
+  url: string;
+  /** HTTP method */
+  method: string;
+  /** HTTP status code (for response errors) */
+  status?: number;
+  /** Failure reason (for request failures) */
+  failure?: string;
+}
+
+export interface AnalysisReport {
+  /** Page URL */
+  url: string;
+  /** Page title */
+  title: string;
+  /** ISO timestamp */
+  timestamp: string;
+  /** Analysis duration */
+  duration: string;
+  /** QA score (0-100) */
+  score: number | null;
+  /** AI-generated summary */
+  summary: string;
+  /** All bugs found */
+  bugs: Bug[];
+  /** Only critical/high severity bugs (convenience property) */
+  criticalBugs: Bug[];
+  /** AI recommendations */
+  recommendations: string[];
+  /** Console errors captured */
+  consoleErrors: string[];
+  /** Network errors captured */
+  networkErrors: NetworkError[];
+  /** Screenshots taken */
+  screenshots: Screenshot[];
+  /** Viewports tested */
+  viewports: string[];
+  /** Focus area used */
+  focus: string;
+}
+
+export interface ViewportConfig {
+  width: number;
+  height: number;
+  name: string;
+}
+
+/**
+ * Analyze a page with AI
+ *
+ * @example
+ * ```typescript
+ * import { test, expect } from '@playwright/test';
+ * import { analyzeWithAI } from 'qaie';
+ *
+ * test('AI QA: homepage', async ({ page }) => {
+ *   await page.goto('/');
+ *   const report = await analyzeWithAI(page);
+ *   expect(report.criticalBugs).toHaveLength(0);
+ * });
+ * ```
+ */
+export function analyzeWithAI(page: Page, options?: AnalysisOptions): Promise<AnalysisReport>;
+
+/**
+ * Create a configured analyzer with default options
+ *
+ * @example
+ * ```typescript
+ * const analyze = createAnalyzer({ viewports: ['desktop', 'mobile', 'tablet'] });
+ *
+ * test('homepage', async ({ page }) => {
+ *   await page.goto('/');
+ *   const report = await analyze(page);
+ * });
+ * ```
+ */
+export function createAnalyzer(
+  defaultOptions?: AnalysisOptions,
+): (page: Page, options?: AnalysisOptions) => Promise<AnalysisReport>;
+
+/**
+ * Attach all screenshots from a report to the Playwright test
+ *
+ * @example
+ * ```typescript
+ * test('AI QA', async ({ page }, testInfo) => {
+ *   await page.goto('/');
+ *   const report = await analyzeWithAI(page);
+ *   await attachScreenshots(testInfo, report);
+ * });
+ * ```
+ */
+export function attachScreenshots(testInfo: TestInfo, report: AnalysisReport): Promise<void>;
+
+/**
+ * Attach the bug report as a JSON attachment
+ */
+export function attachBugReport(testInfo: TestInfo, report: AnalysisReport): Promise<void>;
+
+/**
+ * Viewport configurations
+ */
+export const VIEWPORT_CONFIGS: Record<string, ViewportConfig>;