comfy-qa 1.0.0 → 1.2.1

package/src/agent/research.ts

@@ -0,0 +1,221 @@
+import { $ } from "bun";
+import type { PRInfo, IssueInfo } from "../utils/github";
+
+/** Call Claude via CLI (already authenticated) or SDK if ANTHROPIC_API_KEY is set */
+async function callClaude(prompt: string): Promise<string> {
+  const apiKey = process.env.ANTHROPIC_API_KEY_QA ?? process.env.ANTHROPIC_API_KEY;
+  if (apiKey) {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic({ apiKey });
+    const response = await client.messages.create({
+      model: "claude-opus-4-6",
+      max_tokens: 4096,
+      messages: [{ role: "user", content: prompt }],
+    });
+    return response.content[0].type === "text" ? response.content[0].text : "";
+  }
+  // Fallback: pipe through claude CLI via stdin
+  const proc = Bun.spawn(["claude", "--print", "--model", "claude-opus-4-6"], {
+    stdin: new TextEncoder().encode(prompt),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const output = await new Response(proc.stdout).text();
+  await proc.exited;
+  return output;
+}
+
+/** Extract JSON from Claude response, handling code blocks and markdown wrapping */
+function parseResearchJSON(text: string): ResearchResult {
+  // Try extracting from ```json ... ``` code block first
+  const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+  const candidate = codeBlockMatch ? codeBlockMatch[1].trim() : text;
+
+  // Find the outermost JSON object
+  const jsonMatch = candidate.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) throw new Error("Research agent returned no JSON");
+
+  try {
+    return JSON.parse(jsonMatch[0]) as ResearchResult;
+  } catch (e) {
+    // Try cleaning common issues: trailing commas, comments
+    const cleaned = jsonMatch[0]
+      .replace(/,\s*([\]}])/g, "$1")  // trailing commas
+      .replace(/\/\/.*$/gm, "");       // line comments
+    return JSON.parse(cleaned) as ResearchResult;
+  }
+}
+
+export interface ResearchResult {
+  summary: string;
+  bugType: "bug" | "feature" | "regression" | "performance" | "unknown";
+  severity: "critical" | "high" | "medium" | "low";
+  affectedArea: string;
+  reproductionSteps: string[];
+  expectedBehavior: string;
+  actualBehavior: string;
+  rootCauseSummary: string;
+  qaChecklist: QAChecklistItem[];
+  testScenarios: TestScenario[];
+  risks: string[];
+  relatedFiles: string[];
+}
+
+export interface QAChecklistItem {
+  id: string;
+  category: "functional" | "visual" | "regression" | "edge_case" | "performance";
+  description: string;
+  steps: string[];
+  expectedResult: string;
+  priority: "P0" | "P1" | "P2";
+  status: "pending" | "pass" | "fail" | "blocked";
+}
+
+export interface TestScenario {
+  name: string;
+  description: string;
+  preconditions: string[];
+  steps: string[];
+  expectedOutcome: string;
+  playwrightHint: string;
+}
+
+export async function researchPR(pr: PRInfo): Promise<ResearchResult> {
+  console.log(`  [research] Analyzing PR #${pr.number}: ${pr.title}`);
+
+  const filesSummary = pr.files
+    .slice(0, 30)
+    .map((f) => `  ${f.path} (+${f.additions}/-${f.deletions})`)
+    .join("\n");
+
+  const commentsSummary = pr.comments
+    .slice(0, 10)
+    .map((c) => `  [${c.author}]: ${c.body.slice(0, 300)}`)
+    .join("\n---\n");
+
+  const prompt = `You are a senior QA engineer analyzing a GitHub PR for ComfyUI (a node-based AI image generation UI).
+
+## PR #${pr.number}: ${pr.title}
+**URL**: ${pr.url}
+**Author**: ${pr.author}
+**Branch**: ${pr.headRefName} → ${pr.baseRefName}
+**Labels**: ${pr.labels.join(", ") || "none"}
+
+## PR Description
+${pr.body.slice(0, 3000)}
+
+## Changed Files (${pr.files.length} total)
+${filesSummary}
+
+## Key Comments
+${commentsSummary || "(none)"}
+
+---
+
+Produce a comprehensive QA analysis as JSON with this exact schema:
+{
+  "summary": "2-3 sentence executive summary",
+  "bugType": "bug|feature|regression|performance|unknown",
+  "severity": "critical|high|medium|low",
+  "affectedArea": "e.g. canvas, workflow tabs, sidebar, node editor",
+  "reproductionSteps": ["step 1", "step 2", ...],
+  "expectedBehavior": "what should happen",
+  "actualBehavior": "what actually happens (the bug)",
+  "rootCauseSummary": "technical root cause in 1-2 sentences",
+  "qaChecklist": [
+    {
+      "id": "QA-001",
+      "category": "functional|visual|regression|edge_case|performance",
+      "description": "test description",
+      "steps": ["step 1", ...],
+      "expectedResult": "expected outcome",
+      "priority": "P0|P1|P2",
+      "status": "pending"
+    }
+  ],
+  "testScenarios": [
+    {
+      "name": "scenario name",
+      "description": "what this tests",
+      "preconditions": ["precondition 1", ...],
+      "steps": ["step 1", ...],
+      "expectedOutcome": "what should happen",
+      "playwrightHint": "which playwright selectors/actions to use"
+    }
+  ],
+  "risks": ["risk 1", "risk 2"],
+  "relatedFiles": ["path/to/file.ts"]
+}
+
+Create 5-8 QA checklist items covering: happy path, regression, edge cases, visual checks.
+Create 3-5 test scenarios focused on the core bug/feature.
+Be specific and actionable. Use ComfyUI-specific terminology.`;
+
+  const text = await callClaude(prompt);
+  return parseResearchJSON(text);
+}
+
+export async function researchIssue(issue: IssueInfo): Promise<ResearchResult> {
+  console.log(`  [research] Analyzing issue #${issue.number}: ${issue.title}`);
+
+  const commentsSummary = issue.comments
+    .slice(0, 8)
+    .map((c) => `  [${c.author}]: ${c.body.slice(0, 500)}`)
+    .join("\n---\n");
+
+  const prompt = `You are a senior QA engineer analyzing a GitHub issue for ComfyUI (a node-based AI image generation UI).
+
+## Issue #${issue.number}: ${issue.title}
+**URL**: ${issue.url}
+**Author**: ${issue.author}
+**Labels**: ${issue.labels.join(", ") || "none"}
+**State**: ${issue.state}
+
+## Issue Description
+${issue.body.slice(0, 3000)}
+
+## Comments (${issue.comments.length} total)
+${commentsSummary || "(none)"}
+
+---
+
+Produce a comprehensive QA analysis as JSON with this exact schema:
+{
+  "summary": "2-3 sentence executive summary",
+  "bugType": "bug|feature|regression|performance|unknown",
+  "severity": "critical|high|medium|low",
+  "affectedArea": "e.g. canvas, workflow tabs, sidebar, node editor",
+  "reproductionSteps": ["step 1", "step 2", ...],
+  "expectedBehavior": "what should happen",
+  "actualBehavior": "what actually happens",
+  "rootCauseSummary": "technical root cause hypothesis",
+  "qaChecklist": [
+    {
+      "id": "QA-001",
+      "category": "functional|visual|regression|edge_case|performance",
+      "description": "test description",
+      "steps": ["step 1", ...],
+      "expectedResult": "expected outcome",
+      "priority": "P0|P1|P2",
+      "status": "pending"
+    }
+  ],
+  "testScenarios": [
+    {
+      "name": "scenario name",
+      "description": "what this tests",
+      "preconditions": ["precondition 1", ...],
+      "steps": ["step 1", ...],
+      "expectedOutcome": "what should happen",
+      "playwrightHint": "playwright selectors/actions hint"
+    }
+  ],
+  "risks": ["risk 1", "risk 2"],
+  "relatedFiles": []
+}
+
+Create 5-8 QA checklist items. Create 3-5 test scenarios. Be specific and actionable.`;
+
+  const text = await callClaude(prompt);
+  return parseResearchJSON(text);
+}

package/src/browser/hud.ts

@@ -0,0 +1,136 @@
+import type { Page } from "playwright";
+
+/**
+ * Inject the comfy-qa info panel (step/plan/status/annotation).
+ * Cursor + keystroke display is handled by qa-hud.
+ */
+export async function injectHUD(page: Page, title: string): Promise<void> {
+  await page.addStyleTag({
+    content: `
+      #comfy-qa-hud {
+        position: fixed;
+        top: 12px;
+        left: 12px;
+        z-index: 2147483640;
+        background: rgba(0,0,0,0.82);
+        color: #00ff88;
+        font-family: 'JetBrains Mono', 'Fira Code', monospace;
+        font-size: 13px;
+        padding: 10px 14px;
+        border-radius: 8px;
+        border: 1px solid #00ff88;
+        min-width: 340px;
+        pointer-events: none;
+        line-height: 1.6;
+        box-shadow: 0 0 20px rgba(0,255,136,0.3);
+      }
+      #comfy-qa-hud .hud-title { color: #fff; font-weight: bold; margin-bottom: 4px; font-size: 11px; letter-spacing: 1px; text-transform: uppercase; }
+      #comfy-qa-hud .hud-step { color: #ffeb3b; }
+      #comfy-qa-hud .hud-plan { color: #80deea; font-size: 11px; margin-top: 4px; }
+      #comfy-qa-hud .hud-status { color: #ff9800; }
+      #comfy-qa-hud .hud-ts { color: #666; font-size: 10px; }
+      #comfy-qa-annotation {
+        position: fixed;
+        z-index: 2147483639;
+        background: rgba(255,235,59,0.9);
+        color: #000;
+        padding: 6px 10px;
+        border-radius: 4px;
+        font-family: monospace;
+        font-size: 12px;
+        font-weight: bold;
+        pointer-events: none;
+        display: none;
+        max-width: 320px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.5);
+      }
+    `,
+  });
+
+  await page.evaluate((t: string) => {
+    // Info panel
+    const hud = document.createElement("div");
+    hud.id = "comfy-qa-hud";
+    hud.innerHTML = `
+      <div class="hud-title">Comfy-QA Agent</div>
+      <div class="hud-step" id="hud-step">Initializing…</div>
+      <div class="hud-plan" id="hud-plan"></div>
+      <div class="hud-status" id="hud-status"></div>
+      <div class="hud-ts" id="hud-ts"></div>
+    `;
+    document.body.appendChild(hud);
+
+    // Annotation bubble
+    const ann = document.createElement("div");
+    ann.id = "comfy-qa-annotation";
+    document.body.appendChild(ann);
+
+    // Expose update APIs
+    (window as any).__comfyQA = {
+      setStep: (text: string) => {
+        const el = document.getElementById("hud-step");
+        if (el) el.textContent = "▶ " + text;
+        const ts = document.getElementById("hud-ts");
+        if (ts) ts.textContent = new Date().toISOString();
+      },
+      setPlan: (text: string) => {
+        const el = document.getElementById("hud-plan");
+        if (el) el.textContent = "📋 " + text;
+      },
+      setStatus: (text: string) => {
+        const el = document.getElementById("hud-status");
+        if (el) el.textContent = "⚡ " + text;
+      },
+      annotate: (x: number, y: number, text: string, durationMs = 2500) => {
+        const a = document.getElementById("comfy-qa-annotation");
+        if (!a) return;
+        a.textContent = text;
+        a.style.left = Math.min(x + 20, window.innerWidth - 340) + "px";
+        a.style.top = Math.max(y - 40, 10) + "px";
+        a.style.display = "block";
+        setTimeout(() => { a.style.display = "none"; }, durationMs);
+      },
+    };
+
+    (window as any).__comfyQA.setStep("Starting QA session: " + t);
+  }, title);
+}
+
+/** Update HUD step text */
+export async function hudStep(page: Page, step: string): Promise<void> {
+  try {
+    await page.evaluate((s: string) => (window as any).__comfyQA?.setStep(s), step);
+  } catch {}
+  console.log(`  [hud] ${step}`);
+}
+
+/** Update HUD plan text */
+export async function hudPlan(page: Page, plan: string): Promise<void> {
+  try {
+    await page.evaluate((s: string) => (window as any).__comfyQA?.setPlan(s), plan);
+  } catch {}
+}
+
+/** Update HUD status */
+export async function hudStatus(page: Page, status: string): Promise<void> {
+  try {
+    await page.evaluate((s: string) => (window as any).__comfyQA?.setStatus(s), status);
+  } catch {}
+}
+
+/** Show annotation bubble near coordinates */
+export async function hudAnnotate(
+  page: Page,
+  x: number,
+  y: number,
+  text: string,
+  durationMs = 3000
+): Promise<void> {
+  try {
+    await page.evaluate(
+      ({ x, y, text, durationMs }: { x: number; y: number; text: string; durationMs: number }) =>
+        (window as any).__comfyQA?.annotate(x, y, text, durationMs),
+      { x, y, text, durationMs }
+    );
+  } catch {}
+}

package/src/browser/recorder.ts

@@ -0,0 +1,131 @@
+import { chromium, type Browser, type BrowserContext, type Page } from "playwright";
+import * as path from "path";
+import * as fs from "fs";
+import { applyHud } from "../../lib/demowright/dist/setup.mjs";
+import { injectHUD, hudStep, hudPlan, hudStatus, hudAnnotate } from "./hud";
+
+export interface RecorderSession {
+  page: Page;
+  context: BrowserContext;
+  browser: Browser;
+  screenshotDir: string;
+  screenshots: string[];
+  step: (text: string) => Promise<void>;
+  plan: (text: string) => Promise<void>;
+  status: (text: string) => Promise<void>;
+  annotate: (x: number, y: number, text: string, ms?: number) => Promise<void>;
+  screenshot: (name: string) => Promise<string>;
+  /** Set narration durations and the demo start timestamp */
+  attachNarration: (durations: Map<string, number>) => void;
+  /** Run a narrated step: updates HUD and waits for the segment's audio duration */
+  narrate: (id: string, hudText: string) => Promise<void>;
+  /** Get demo start time (set when first narrate() is called or attachNarration) */
+  getDemoStartMs: () => number;
+  stop: () => Promise<void>;
+}
+
+export async function startRecorder(
+  outputDir: string,
+  videoName = "qa-session",
+  viewportWidth = 1280,
+  viewportHeight = 800
+): Promise<RecorderSession> {
+  fs.mkdirSync(outputDir, { recursive: true });
+  const screenshotDir = path.join(outputDir, "screenshots");
+  fs.mkdirSync(screenshotDir, { recursive: true });
+
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: viewportWidth, height: viewportHeight },
+    recordVideo: {
+      dir: outputDir,
+      size: { width: viewportWidth, height: viewportHeight },
+    },
+  });
+
+  // Apply qa-hud: cursor overlay, keystroke display, action slowdown
+  await applyHud(context, {
+    cursor: true,
+    keyboard: true,
+    cursorStyle: "default",
+    actionDelay: 150,
+  });
+
+  const page = await context.newPage();
+  const screenshots: string[] = [];
+
+  page.on("console", (msg) => {
+    if (msg.type() === "error") {
+      console.error(`  [browser:error] ${msg.text()}`);
+    }
+  });
+
+  const step = async (text: string) => {
+    await hudStep(page, text);
+    await page.waitForTimeout(300);
+  };
+  const plan = async (text: string) => hudPlan(page, text);
+  const status = async (text: string) => hudStatus(page, text);
+  const annotate = async (x: number, y: number, text: string, ms = 3000) =>
+    hudAnnotate(page, x, y, text, ms);
+
+  const screenshot = async (name: string): Promise<string> => {
+    const file = path.join(screenshotDir, `${name}.png`);
+    await page.screenshot({ path: file, fullPage: false });
+    screenshots.push(file);
+    console.log(`  [screenshot] ${file}`);
+    return file;
+  };
+
+  let narrationDurations: Map<string, number> | null = null;
+  let demoStartMs = 0;
+  const recordingStartMs = Date.now();
+
+  const attachNarration = (durations: Map<string, number>) => {
+    narrationDurations = durations;
+    demoStartMs = Date.now();
+  };
+
+  const getDemoStartMs = () => demoStartMs || recordingStartMs;
+
+  const narrate = async (id: string, hudText: string) => {
+    if (!demoStartMs) demoStartMs = Date.now();
+    await hudStep(page, hudText);
+    const dur = narrationDurations?.get(id) ?? 1500;
+    const segStart = Date.now();
+    // Caller can do work between this and we'll sleep the remainder
+    // For now just sleep the full duration since we don't yield mid-call
+    const elapsed = Date.now() - segStart;
+    const remaining = dur - elapsed;
+    if (remaining > 50) await page.waitForTimeout(remaining);
+  };
+
+  const stop = async () => {
+    await page.waitForTimeout(1500);
+    const video = await page.video()?.path();
+    await context.close();
+    await browser.close();
+    if (video) {
+      const dest = path.join(outputDir, `${videoName}.webm`);
+      fs.renameSync(video, dest);
+      console.log(`  [video] Saved → ${dest}`);
+    }
+  };
+
+  return { page, context, browser, screenshotDir, screenshots, step, plan, status, annotate, screenshot, attachNarration, narrate, getDemoStartMs, stop };
+}
+
+/** Navigate to URL and inject comfy-qa info panel */
+export async function navigateWithHUD(
+  session: RecorderSession,
+  url: string,
+  title: string
+): Promise<void> {
+  await session.page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+  try {
+    await injectHUD(session.page, title);
+  } catch {
+    // HUD injection fails on some pages (cross-origin) — that's OK
+  }
+  await session.page.waitForTimeout(500);
+}

package/src/cli.ts

@@ -1,37 +1,78 @@
 #!/usr/bin/env bun
 
-import { parseArgs } from "util";
-
-const { values, positionals } = parseArgs({
-  args: Bun.argv.slice(2),
-  options: {
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" },
-  },
-  allowPositionals: true,
-});
-
-if (values.version) {
-  const pkg = await import("../package.json");
-  console.log(pkg.default.version);
-  process.exit(0);
-}
+import { commandPR } from "./commands/pr";
+import { commandIssue } from "./commands/issue";
+import { commandFull } from "./commands/full";
+import { commandSetup } from "./commands/setup";
+import { parseGitHubUrl } from "./utils/parse-url";
+
+const args = Bun.argv.slice(2);
+const cmd = args[0];
+const rest = args.slice(1);
+
+const HELP = `cmqa — E2E QA automation for frontend repos
+
+USAGE
+  cmqa setup                              Emit setup prompt for your agent
+  cmqa <github-url>                       Auto-detect PR or issue from URL
+  cmqa pr    <github-url | owner/repo#N>  Research & QA a pull request
+  cmqa issue <github-url | owner/repo#N>  Research & QA an issue / bug report
+  cmqa full  <owner/repo>                 Batch QA recent open issues
 
-if (values.help || positionals.length === 0) {
-  console.log(`comfy-qa - ComfyUI QA automation CLI
+SETUP (one-shot)
+  Tell your agent: "run npx cmqa setup"
+  The agent reads the emitted prompt and sets up a complete QA workflow
+  for the current repo — Playwright config, E2E tests, skill files, etc.
 
-Usage:
-  comfy-qa <command> [options]
+OPTIONS
+  --no-record         Disable video recording (recording is ON by default)
+  --add-comment       Post QA report as a comment on the GitHub issue/PR
+  --comfy-url <url>   Point to a running dev server (default: auto-detect)
+  --limit N           (full only) Number of issues to process [default: 5]
+  -h, --help          Show this help
+  -v, --version       Show version
 
-Commands:
-  (none yet)
+EXAMPLES
+  cmqa setup
+  cmqa https://github.com/org/repo/pull/123
+  cmqa https://github.com/org/repo/issues/456
+  cmqa pr org/repo#123
+  cmqa issue org/repo#456 --no-record
+  cmqa full org/repo --limit 3
+`;
 
-Options:
-  -h, --help     Show this help message
-  -v, --version  Show version
-`);
+if (!cmd || cmd === "-h" || cmd === "--help") {
+  console.log(HELP);
   process.exit(0);
 }
 
-console.error(`Unknown command: ${positionals[0]}`);
-process.exit(1);
+if (cmd === "-v" || cmd === "--version") {
+  const pkg = await import("../package.json");
+  console.log(pkg.default.version);
+  process.exit(0);
+}
+
+// Try GitHub URL as first arg (no subcommand needed)
+const urlParsed = parseGitHubUrl(cmd);
+if (urlParsed) {
+  const handler = urlParsed.type === "pr" ? commandPR : commandIssue;
+  await handler([urlParsed.ref, ...rest]);
+} else {
+  switch (cmd) {
+    case "setup":
+      await commandSetup(rest);
+      break;
+    case "pr":
+      await commandPR(rest);
+      break;
+    case "issue":
+      await commandIssue(rest);
+      break;
+    case "full":
+      await commandFull(rest);
+      break;
+    default:
+      console.error(`Unknown command: ${cmd}\nRun 'cmqa --help' for usage.`);
+      process.exit(1);
+  }
+}

package/src/commands/full.ts

@@ -0,0 +1,40 @@
+import { runQA } from "../agent/orchestrator";
+import { fetchRecentIssues, parseRef } from "../utils/github";
+
+export async function commandFull(args: string[]): Promise<void> {
+  const repoRef = args.find((a) => !a.startsWith("--"));
+  const record = !args.includes("--no-record");
+  const limitIdx = args.indexOf("--limit");
+  const limit = limitIdx >= 0 ? parseInt(args[limitIdx + 1]) : 5;
+  const comfyUrlIdx = args.indexOf("--comfy-url");
+  const comfyUrl = comfyUrlIdx >= 0 ? args[comfyUrlIdx + 1] : undefined;
+
+  if (!repoRef) {
+    console.error("Usage: cmqa full <owner/repo> [--limit N] [--no-record]");
+    process.exit(1);
+  }
+
+  const { owner, repo } = parseRef(repoRef);
+  console.log(`\n[full] Fetching top ${limit} open issues from ${owner}/${repo}…`);
+
+  const issues = await fetchRecentIssues(owner, repo, limit);
+  console.log(`  Found ${issues.length} issues\n`);
+
+  for (const issue of issues) {
+    console.log(`\n${"─".repeat(60)}`);
+    console.log(`  Processing issue #${issue.number}: ${issue.title}`);
+    try {
+      await runQA({
+        ref: `${owner}/${repo}#${issue.number}`,
+        type: "issue",
+        record,
+        outputBase: ".comfy-qa",
+        comfyUrl,
+      });
+    } catch (err) {
+      console.error(`  ✗ Failed: ${err}`);
+    }
+  }
+
+  console.log(`\n[full] Done. Reports in .comfy-qa/`);
+}

package/src/commands/issue.ts

@@ -0,0 +1,23 @@
+import { runQA } from "../agent/orchestrator";
+import { parseGitHubUrl } from "../utils/parse-url";
+
+export async function commandIssue(args: string[]): Promise<void> {
+  let ref = args.find((a) => !a.startsWith("--"));
+  const record = !args.includes("--no-record");
+  const comfyUrlIdx = args.indexOf("--comfy-url");
+  const comfyUrl = comfyUrlIdx >= 0 ? args[comfyUrlIdx + 1] : undefined;
+
+  // Accept GitHub URL: cmqa issue https://github.com/org/repo/issues/456
+  if (ref) {
+    const parsed = parseGitHubUrl(ref);
+    if (parsed) ref = parsed.ref;
+  }
+
+  if (!ref) {
+    console.error("Usage: cmqa issue <github-url | owner/repo#number>");
+    console.error("       cmqa issue https://github.com/org/repo/issues/456");
+    process.exit(1);
+  }
+
+  await runQA({ ref, type: "issue", record, outputBase: ".comfy-qa", comfyUrl });
+}

package/src/commands/pr.ts

@@ -0,0 +1,23 @@
+import { runQA } from "../agent/orchestrator";
+import { parseGitHubUrl } from "../utils/parse-url";
+
+export async function commandPR(args: string[]): Promise<void> {
+  let ref = args.find((a) => !a.startsWith("--"));
+  const record = !args.includes("--no-record");
+  const comfyUrlIdx = args.indexOf("--comfy-url");
+  const comfyUrl = comfyUrlIdx >= 0 ? args[comfyUrlIdx + 1] : undefined;
+
+  // Accept GitHub URL: cmqa pr https://github.com/org/repo/pull/123
+  if (ref) {
+    const parsed = parseGitHubUrl(ref);
+    if (parsed) ref = parsed.ref;
+  }
+
+  if (!ref) {
+    console.error("Usage: cmqa pr <github-url | owner/repo#number>");
+    console.error("       cmqa pr https://github.com/org/repo/pull/123");
+    process.exit(1);
+  }
+
+  await runQA({ ref, type: "pr", record, outputBase: ".comfy-qa", comfyUrl });
+}