supipowers 0.3.0 → 0.5.0

package/src/commands/qa.ts

@@ -1,184 +1,268 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
-import { detectAndCache } from "../qa/detector.js";
-import { notifyInfo, notifyError } from "../notifications/renderer.js";
-import { findActiveSession, findSessionWithFailures } from "../storage/qa-sessions.js";
-import {
-  createNewSession,
-  advancePhase,
-  getFailedTests,
-  getNextPhase,
-  getPhaseStatusLine,
-} from "../qa/session.js";
-import { buildDiscoveryPrompt } from "../qa/phases/discovery.js";
-import { buildMatrixPrompt } from "../qa/phases/matrix.js";
-import { buildExecutionPrompt } from "../qa/phases/execution.js";
-import { buildReportingPrompt } from "../qa/phases/reporting.js";
-import type { QaPhase, QaSessionLedger } from "../types.js";
-
-const PHASE_LABELS: Record<QaPhase, string> = {
-  discovery: "Discovery — Scan for test cases",
-  matrix: "Matrix — Build traceability matrix",
-  execution: "Execution — Run tests",
-  reporting: "Reporting — Generate summary",
-};
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { notifyInfo, notifyError, notifyWarning } from "../notifications/renderer.js";
+import { loadE2eQaConfig, saveE2eQaConfig, DEFAULT_E2E_QA_CONFIG } from "../qa/config.js";
+import { loadE2eMatrix } from "../qa/matrix.js";
+import { createNewE2eSession } from "../qa/session.js";
+import { buildE2eOrchestratorPrompt } from "../qa/prompt-builder.js";
+import { findActiveSession, getSessionDir } from "../storage/qa-sessions.js";
+import type { E2eQaConfig, AppType, E2eRegression } from "../qa/types.js";
 
-export function registerQaCommand(pi: ExtensionAPI): void {
-  pi.registerCommand("supi:qa", {
-    description: "Run QA pipeline with session management (discovery → matrix → execution → reporting)",
-    async handler(args, ctx) {
-      const framework = detectAndCache(ctx.cwd);
-
-      if (!framework) {
-        notifyError(
-          ctx,
-          "No test framework detected",
-          "Configure manually via /supi:config"
-        );
-        return;
-      }
+function getScriptsDir(): string {
+  return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "qa", "scripts");
+}
 
-      // ── Step 1: Session selection ──────────────────────────────────
-      let ledger: QaSessionLedger | null = null;
+function findSkillPath(skillName: string): string | null {
+  const candidates = [
+    path.join(process.cwd(), "skills", skillName, "SKILL.md"),
+    path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "skills", skillName, "SKILL.md"),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
 
-      const activeSession = findActiveSession(ctx.cwd);
-      const failedSession = findSessionWithFailures(ctx.cwd);
+const APP_TYPE_OPTIONS = [
+  "nextjs-app — Next.js App Router",
+  "nextjs-pages — Next.js Pages Router",
+  "react-router — React with React Router",
+  "vite — Vite-based app",
+  "express — Express.js server",
+  "generic — Other web app",
+];
 
-      if (ctx.hasUI && !args?.trim()) {
-        const sessionOptions: string[] = [];
+const BROWSER_OPTIONS = [
+  "chromium (recommended)",
+  "firefox",
+  "webkit",
+];
 
-        if (failedSession) {
-          const failCount = failedSession.results.filter((r) => r.status === "fail").length;
-          sessionOptions.push(`Resume ${failedSession.id} (${failCount} failed test${failCount !== 1 ? "s" : ""})`);
-        } else if (activeSession) {
-          const next = getNextPhase(activeSession);
-          sessionOptions.push(`Resume ${activeSession.id} (${next ?? "all phases done"} pending)`);
-        }
+const RETRY_OPTIONS = [
+  "1",
+  "2 (recommended)",
+  "3",
+];
 
-        sessionOptions.push("Start new session");
+async function runSetupWizard(
+  ctx: any,
+  detectedAppType: string | null,
+  detectedDevCommand: string | null,
+  detectedPort: number | null,
+): Promise<E2eQaConfig | null> {
+  // 1. App type
+  const appTypeChoice = await ctx.ui.select(
+    "App type",
+    APP_TYPE_OPTIONS,
+    { helpText: detectedAppType ? `Auto-detected: ${detectedAppType}` : "Select your web app framework" },
+  );
+  if (!appTypeChoice) return null;
+  const appType = appTypeChoice.split(" ")[0] as AppType;
 
-        if (sessionOptions.length > 1) {
-          const choice = await ctx.ui.select(
-            "QA Session",
-            sessionOptions,
-            { helpText: "Select session · Esc to cancel" },
-          );
-          if (!choice) return;
+  // 2. Dev command
+  const defaultDev = detectedDevCommand || "npm run dev";
+  const devCommand = await ctx.ui.input(
+    "Dev server command",
+    defaultDev,
+    { helpText: "Command to start your development server" },
+  );
+  if (devCommand === undefined) return null;
 
-          if (choice.startsWith("Resume")) {
-            ledger = failedSession ?? activeSession;
-          }
-        }
-      }
+  // 3. Port
+  const defaultPort = String(detectedPort || 3000);
+  const portStr = await ctx.ui.input(
+    "Dev server port",
+    defaultPort,
+    { helpText: "Port your dev server runs on" },
+  );
+  if (portStr === undefined) return null;
+  const port = parseInt(portStr, 10) || 3000;
 
-      // Create new session if none selected
-      if (!ledger) {
-        ledger = createNewSession(ctx.cwd, framework.name);
-        notifyInfo(ctx, "QA session created", ledger.id);
-      }
+  // 4. Browser
+  const browserChoice = await ctx.ui.select(
+    "Browser for E2E tests",
+    BROWSER_OPTIONS,
+    { helpText: "Playwright browser to use" },
+  );
+  if (!browserChoice) return null;
+  const browser = browserChoice.split(" ")[0] as "chromium" | "firefox" | "webkit";
 
-      // ── Step 2: Phase selection ────────────────────────────────────
-      type PhaseAction =
-        | { type: "run-phase"; phase: QaPhase }
-        | { type: "rerun-failed" };
+  // 5. Max retries
+  const retryChoice = await ctx.ui.select(
+    "Max test retries",
+    RETRY_OPTIONS,
+    { helpText: "How many times to retry failing tests" },
+  );
+  if (!retryChoice) return null;
+  const maxRetries = parseInt(retryChoice, 10);
 
-      let action: PhaseAction | null = null;
-      const nextPhase = getNextPhase(ledger);
-      const failedTests = getFailedTests(ledger);
+  return {
+    app: {
+      type: appType,
+      devCommand: devCommand || defaultDev,
+      port,
+      baseUrl: `http://localhost:${port}`,
+    },
+    playwright: {
+      browser,
+      headless: true,
+      timeout: 30000,
+    },
+    execution: {
+      maxRetries,
+      maxFlows: 20,
+    },
+  };
+}
 
-      if (ctx.hasUI && !args?.trim()) {
-        const phaseOptions: string[] = [];
+export function registerQaCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:qa", {
+    description: "Run autonomous E2E product testing pipeline with playwright",
+    async handler(args, ctx) {
+      const scriptsDir = getScriptsDir();
 
-        // Offer re-run failed if there are failures
-        if (failedTests.length > 0) {
-          phaseOptions.push(`Re-run ${failedTests.length} failed test${failedTests.length !== 1 ? "s" : ""} only`);
+      // ── Step 1: Detect app type ─────────────────────────────────────
+      let detectedType: string | null = null;
+      let detectedDevCommand: string | null = null;
+      let detectedPort: number | null = null;
+
+      try {
+        const detectResult = await pi.exec("bash", [
+          path.join(scriptsDir, "detect-app-type.sh"),
+          ctx.cwd,
+        ], { cwd: ctx.cwd });
+
+        if (detectResult.code === 0) {
+          const detected = JSON.parse(detectResult.stdout.trim());
+          detectedType = detected.type;
+          detectedDevCommand = detected.devCommand;
+          detectedPort = detected.port;
         }
+      } catch { /* proceed without detection */ }
+
+      // ── Step 2: Ensure playwright ────────────────────────────────────
+      try {
+        const pwResult = await pi.exec("bash", [
+          path.join(scriptsDir, "ensure-playwright.sh"),
+          ctx.cwd,
+        ], { cwd: ctx.cwd });
 
-        // Offer starting from next pending phase
-        if (nextPhase) {
-          phaseOptions.push(PHASE_LABELS[nextPhase]);
+        if (pwResult.code !== 0) {
+          notifyWarning(ctx, "Playwright setup issue", "Could not verify playwright installation. The agent will handle it.");
         }
+      } catch {
+        notifyWarning(ctx, "Playwright check skipped", "Will be handled during execution");
+      }
+
+      // ── Step 3: Load or create config ────────────────────────────────
+      let config = loadE2eQaConfig(ctx.cwd);
+
+      if (!config && ctx.hasUI) {
+        config = await runSetupWizard(ctx, detectedType, detectedDevCommand, detectedPort);
+        if (!config) return; // user cancelled
+        saveE2eQaConfig(ctx.cwd, config);
+        ctx.ui.notify("E2E QA config saved to .omp/supipowers/e2e-qa.json", "info");
+      }
+
+      if (!config) {
+        // Use defaults with detected values
+        config = {
+          ...DEFAULT_E2E_QA_CONFIG,
+          app: {
+            type: (detectedType as AppType) || "generic",
+            devCommand: detectedDevCommand || "npm run dev",
+            port: detectedPort || 3000,
+            baseUrl: `http://localhost:${detectedPort || 3000}`,
+          },
+        };
+      }
 
-        if (phaseOptions.length > 1) {
-          const statusLine = getPhaseStatusLine(ledger);
-          const choice = await ctx.ui.select(
-            `QA Phase · ${statusLine}`,
-            phaseOptions,
-            { helpText: "Select action · Esc to cancel" },
-          );
-          if (!choice) return;
-
-          if (choice.startsWith("Re-run")) {
-            action = { type: "rerun-failed" };
-          } else {
-            // Extract phase from label
-            const selectedPhase = (Object.entries(PHASE_LABELS) as [QaPhase, string][])
-              .find(([, label]) => label === choice)?.[0];
-            if (selectedPhase) {
-              action = { type: "run-phase", phase: selectedPhase };
-            }
+      // ── Step 4: Check for unresolved regressions ─────────────────────
+      const activeSession = findActiveSession(ctx.cwd);
+      if (activeSession && activeSession.regressions.length > 0 && ctx.hasUI) {
+        const unresolvedRegressions = activeSession.regressions.filter((r: E2eRegression) => !r.resolution);
+        if (unresolvedRegressions.length > 0) {
+          for (const regression of unresolvedRegressions) {
+            const choice = await ctx.ui.select(
+              `Regression: ${regression.flowName}`,
+              [
+                "This is a bug — needs fixing",
+                "Behavior changed intentionally — update the test",
+                "Skip for now",
+              ],
+              { helpText: `Was passing, now fails: ${regression.error}` },
+            );
+            if (!choice) continue;
+            if (choice.startsWith("This is a bug")) regression.resolution = "bug";
+            else if (choice.startsWith("Behavior changed")) regression.resolution = "intentional-change";
+            else regression.resolution = "skipped";
           }
-        } else if (nextPhase) {
-          // Only one option — just run the next phase
-          action = { type: "run-phase", phase: nextPhase };
         }
-      } else if (nextPhase) {
-        action = { type: "run-phase", phase: nextPhase };
       }
 
-      if (!action) {
-        notifyInfo(ctx, "QA pipeline complete", getPhaseStatusLine(ledger));
-        return;
-      }
+      // ── Step 5: Route discovery ──────────────────────────────────────
+      let discoveredRoutes = "";
+      try {
+        const routeResult = await pi.exec("bash", [
+          path.join(scriptsDir, "discover-routes.sh"),
+          ctx.cwd,
+          config.app.type,
+        ], { cwd: ctx.cwd });
 
-      // ── Step 3: Execute ────────────────────────────────────────────
-      let prompt: string;
-
-      if (action.type === "rerun-failed") {
-        ledger = advancePhase(ctx.cwd, ledger, "execution", "running");
-        prompt = buildExecutionPrompt(ledger, { failedOnly: true, failedTests });
-        notifyInfo(ctx, "QA re-running failed tests", `${failedTests.length} test(s)`);
-      } else {
-        const phase = action.phase;
-        ledger = advancePhase(ctx.cwd, ledger, phase, "running");
-
-        switch (phase) {
-          case "discovery":
-            prompt = buildDiscoveryPrompt(framework, ctx.cwd);
-            break;
-          case "matrix":
-            prompt = buildMatrixPrompt(ledger);
-            break;
-          case "execution":
-            prompt = buildExecutionPrompt(ledger);
-            break;
-          case "reporting":
-            prompt = buildReportingPrompt(ledger);
-            break;
+        if (routeResult.code === 0 && routeResult.stdout.trim()) {
+          discoveredRoutes = routeResult.stdout.trim();
         }
+      } catch { /* agent will discover routes manually */ }
 
-        notifyInfo(ctx, `QA phase: ${phase}`, `session: ${ledger.id}`);
+      if (!discoveredRoutes) {
+        discoveredRoutes = '{"path": "/", "file": "unknown", "type": "page", "hasForm": false}';
       }
 
-      // Include session context for the sub-agent
-      const sessionContext = [
-        `\n\n## QA Session Context`,
-        ``,
-        `Session ID: ${ledger.id}`,
-        `Session ledger path: .omp/supipowers/qa-sessions/${ledger.id}/ledger.json`,
-        ``,
-        `Current ledger state:`,
-        "```json",
-        JSON.stringify(ledger, null, 2),
-        "```",
-      ].join("\n");
+      // ── Step 6: Load previous matrix ─────────────────────────────────
+      const previousMatrix = loadE2eMatrix(ctx.cwd);
+      const matrixJson = previousMatrix ? JSON.stringify(previousMatrix, null, 2) : null;
+
+      // ── Step 7: Create session ───────────────────────────────────────
+      const ledger = createNewE2eSession(ctx.cwd, config);
+      const sessionDir = getSessionDir(ctx.cwd, ledger.id);
+
+      // ── Step 8: Load skill ───────────────────────────────────────────
+      let skillContent = "";
+      const skillPath = findSkillPath("qa-strategy");
+      if (skillPath) {
+        try {
+          skillContent = fs.readFileSync(skillPath, "utf-8");
+        } catch { /* proceed without */ }
+      }
+
+      // ── Step 9: Build and send prompt ────────────────────────────────
+      const routeCount = discoveredRoutes.split("\n").filter(Boolean).length;
+
+      const prompt = buildE2eOrchestratorPrompt({
+        cwd: ctx.cwd,
+        appType: config.app,
+        sessionDir,
+        scriptsDir,
+        config,
+        discoveredRoutes,
+        previousMatrix: matrixJson,
+        skillContent,
+      });
 
       pi.sendMessage(
         {
           customType: "supi-qa",
-          content: [{ type: "text", text: prompt + sessionContext }],
+          content: [{ type: "text", text: prompt }],
           display: "none",
         },
-        { deliverAs: "steer" }
+        { deliverAs: "steer" },
+      );
+
+      notifyInfo(
+        ctx,
+        `E2E QA started: ${config.app.type}`,
+        `${routeCount} routes discovered | session ${ledger.id}`,
       );
     },
   });

package/src/commands/supi.ts

@@ -15,7 +15,8 @@ export function handleSupi(pi: ExtensionAPI, ctx: ExtensionContext): void {
       "/supi:plan     — Start collaborative planning",
       "/supi:run      — Execute a plan with sub-agents",
       "/supi:review   — Run quality gates",
-      "/supi:qa       — Run QA pipeline",
+      "/supi:qa       — E2E product testing with Playwright",
+      "/supi:fix-pr   — Fix PR review comments",
       "/supi:release  — Release automation",
       "/supi:config   — Manage configuration",
       "/supi:status   — Check running tasks",

package/src/config/defaults.ts

@@ -19,6 +19,7 @@ export const DEFAULT_CONFIG: SupipowersConfig = {
   qa: {
     framework: null,
     command: null,
+    e2e: false,
   },
   release: {
     pipeline: null,

package/src/config/schema.ts

@@ -25,6 +25,7 @@ const ConfigSchema = Type.Object({
   qa: Type.Object({
     framework: Type.Union([Type.String(), Type.Null()]),
     command: Type.Union([Type.String(), Type.Null()]),
+    e2e: Type.Boolean(),
   }),
   release: Type.Object({
     pipeline: Type.Union([Type.String(), Type.Null()]),

package/src/fix-pr/config.ts

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { FixPrConfig } from "./types.js";
+
+const CONFIG_FILENAME = "fix-pr.json";
+
+function getConfigPath(cwd: string): string {
+  return path.join(cwd, ".omp", "supipowers", CONFIG_FILENAME);
+}
+
+export const DEFAULT_FIX_PR_CONFIG: FixPrConfig = {
+  reviewer: { type: "none", triggerMethod: null },
+  commentPolicy: "answer-selective",
+  loop: { delaySeconds: 180, maxIterations: 3 },
+  models: {
+    orchestrator: { provider: "anthropic", model: "claude-opus-4-6", tier: "high" },
+    planner: { provider: "anthropic", model: "claude-opus-4-6", tier: "high" },
+    fixer: { provider: "anthropic", model: "claude-sonnet-4-6", tier: "low" },
+  },
+};
+
+export function loadFixPrConfig(cwd: string): FixPrConfig | null {
+  const configPath = getConfigPath(cwd);
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8")) as FixPrConfig;
+  } catch {
+    return null;
+  }
+}
+
+export function saveFixPrConfig(cwd: string, config: FixPrConfig): void {
+  const configPath = getConfigPath(cwd);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}