supipowers 0.3.0 → 0.5.0

package/src/qa/session.ts

@@ -1,37 +1,55 @@
-import type { QaPhase, QaPhaseStatus, QaSessionLedger, QaTestCase, QaTestResult } from "../types.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { E2ePhase, E2ePhaseStatus, E2eSessionLedger, E2eQaConfig } from "./types.js";
 import { generateSessionId, createSession, updateSession } from "../storage/qa-sessions.js";
 
-const PHASE_ORDER: QaPhase[] = ["discovery", "matrix", "execution", "reporting"];
+const PHASE_ORDER: E2ePhase[] = ["flow-discovery", "test-generation", "execution", "reporting"];
 
-/** Create a new QA session with all phases pending */
-export function createNewSession(cwd: string, framework: string): QaSessionLedger {
+const PHASE_LABELS: Record<E2ePhase, string> = {
+  "flow-discovery": "Discovery",
+  "test-generation": "Generation",
+  "execution": "Execution",
+  "reporting": "Reporting",
+};
+
+/** Create a new E2E QA session with all phases pending */
+export function createNewE2eSession(cwd: string, config: E2eQaConfig): E2eSessionLedger {
   const now = new Date().toISOString();
-  const ledger: QaSessionLedger = {
+  const ledger: E2eSessionLedger = {
     id: generateSessionId(),
     createdAt: now,
     updatedAt: now,
-    framework,
+    appType: config.app.type,
+    baseUrl: config.app.baseUrl,
     phases: {
-      discovery: { status: "pending" },
-      matrix: { status: "pending" },
-      execution: { status: "pending" },
-      reporting: { status: "pending" },
+      "flow-discovery": { status: "pending" },
+      "test-generation": { status: "pending" },
+      "execution": { status: "pending" },
+      "reporting": { status: "pending" },
     },
-    tests: [],
-    matrix: [],
+    flows: [],
     results: [],
+    regressions: [],
+    config,
   };
+
+  // Create session with subdirectories
   createSession(cwd, ledger);
+
+  const sessionDir = path.join(cwd, ".omp", "supipowers", "qa-sessions", ledger.id);
+  fs.mkdirSync(path.join(sessionDir, "tests"), { recursive: true });
+  fs.mkdirSync(path.join(sessionDir, "screenshots"), { recursive: true });
+
   return ledger;
 }
 
 /** Update a phase's status and timestamps, persist to disk */
-export function advancePhase(
+export function advanceE2ePhase(
   cwd: string,
-  ledger: QaSessionLedger,
-  phase: QaPhase,
-  status: QaPhaseStatus
-): QaSessionLedger {
+  ledger: E2eSessionLedger,
+  phase: E2ePhase,
+  status: E2ePhaseStatus,
+): E2eSessionLedger {
   const now = new Date().toISOString();
   const record = { ...ledger.phases[phase] };
 
@@ -43,7 +61,7 @@ export function advancePhase(
     record.completedAt = now;
   }
 
-  const updated: QaSessionLedger = {
+  const updated: E2eSessionLedger = {
     ...ledger,
     updatedAt: now,
     phases: { ...ledger.phases, [phase]: record },
@@ -52,42 +70,8 @@ export function advancePhase(
   return updated;
 }
 
-/** Merge new test results into the ledger, upserting by testId */
-export function mergeTestResults(
-  ledger: QaSessionLedger,
-  newResults: QaTestResult[]
-): QaSessionLedger {
-  const resultMap = new Map(ledger.results.map((r) => [r.testId, r]));
-
-  for (const incoming of newResults) {
-    const existing = resultMap.get(incoming.testId);
-    if (existing) {
-      resultMap.set(incoming.testId, {
-        ...incoming,
-        retryCount: existing.retryCount + 1,
-      });
-    } else {
-      resultMap.set(incoming.testId, incoming);
-    }
-  }
-
-  return {
-    ...ledger,
-    updatedAt: new Date().toISOString(),
-    results: Array.from(resultMap.values()),
-  };
-}
-
-/** Get test cases whose latest result is "fail" */
-export function getFailedTests(ledger: QaSessionLedger): QaTestCase[] {
-  const failedIds = new Set(
-    ledger.results.filter((r) => r.status === "fail").map((r) => r.testId)
-  );
-  return ledger.tests.filter((t) => failedIds.has(t.id));
-}
-
 /** Get the next phase that is not completed */
-export function getNextPhase(ledger: QaSessionLedger): QaPhase | null {
+export function getNextE2ePhase(ledger: E2eSessionLedger): E2ePhase | null {
   for (const phase of PHASE_ORDER) {
     if (ledger.phases[phase].status !== "completed") return phase;
   }
@@ -95,9 +79,9 @@ export function getNextPhase(ledger: QaSessionLedger): QaPhase | null {
 }
 
 /** Format phase status for TUI display */
-export function getPhaseStatusLine(ledger: QaSessionLedger): string {
+export function getE2ePhaseStatusLine(ledger: E2eSessionLedger): string {
   return PHASE_ORDER.map((phase) => {
-    const label = phase.charAt(0).toUpperCase() + phase.slice(1);
+    const label = PHASE_LABELS[phase];
     const done = ledger.phases[phase].status === "completed";
     return done ? `[done] ${label}` : `[ ] ${label}`;
   }).join(" · ");

package/src/qa/types.ts

@@ -0,0 +1,97 @@
+// ── App Detection ──────────────────────────────────────────────────
+
+export type AppType = "nextjs-app" | "nextjs-pages" | "react-router" | "vite" | "express" | "generic";
+
+export interface AppTypeInfo {
+  type: AppType;
+  devCommand: string;
+  port: number;
+  baseUrl: string;
+}
+
+// ── Configuration ──────────────────────────────────────────────────
+
+export interface PlaywrightConfig {
+  browser: "chromium" | "firefox" | "webkit";
+  headless: boolean;
+  timeout: number;
+}
+
+export interface ExecutionConfig {
+  maxRetries: number;
+  maxFlows: number;
+}
+
+export interface E2eQaConfig {
+  app: AppTypeInfo;
+  playwright: PlaywrightConfig;
+  execution: ExecutionConfig;
+}
+
+// ── Persistent Flow Matrix ─────────────────────────────────────────
+
+export interface E2eFlowRecord {
+  id: string;
+  name: string;
+  entryRoute: string;
+  steps: string[];
+  priority: "critical" | "high" | "medium" | "low";
+  lastStatus: "pass" | "fail" | "untested";
+  lastTestedAt: string | null;
+  lastError?: string;
+  addedAt: string;
+  removedAt?: string;
+}
+
+export interface E2eMatrix {
+  version: string;
+  updatedAt: string;
+  appType: string;
+  flows: E2eFlowRecord[];
+}
+
+// ── Session ────────────────────────────────────────────────────────
+
+export type E2ePhase = "flow-discovery" | "test-generation" | "execution" | "reporting";
+export type E2ePhaseStatus = "pending" | "running" | "completed" | "failed";
+
+export interface E2eFlow {
+  id: string;
+  name: string;
+  entryRoute: string;
+  steps: string[];
+  priority: "critical" | "high" | "medium" | "low";
+  testFile?: string;
+}
+
+export interface E2eTestResult {
+  flowId: string;
+  testFile: string;
+  status: "pass" | "fail" | "skip";
+  duration?: number;
+  error?: string;
+  screenshot?: string;
+  retryCount: number;
+}
+
+export interface E2eRegression {
+  flowId: string;
+  flowName: string;
+  previousStatus: "pass";
+  currentStatus: "fail";
+  error: string;
+  resolution?: "bug" | "intentional-change" | "skipped";
+}
+
+export interface E2eSessionLedger {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  appType: string;
+  baseUrl: string;
+  phases: Record<E2ePhase, { status: E2ePhaseStatus; startedAt?: string; completedAt?: string }>;
+  flows: E2eFlow[];
+  results: E2eTestResult[];
+  regressions: E2eRegression[];
+  config: E2eQaConfig;
+}

package/src/storage/fix-pr-sessions.ts

@@ -0,0 +1,59 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { FixPrSessionLedger } from "../fix-pr/types.js";
+
+const SESSIONS_DIR = "fix-pr-sessions";
+
+function getBaseDir(cwd: string): string {
+  return path.join(cwd, ".omp", "supipowers", SESSIONS_DIR);
+}
+
+export function getSessionDir(cwd: string, sessionId: string): string {
+  return path.join(getBaseDir(cwd), sessionId);
+}
+
+export function generateFixPrSessionId(): string {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const time = now.toTimeString().slice(0, 8).replace(/:/g, "");
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `fpr-${date}-${time}-${rand}`;
+}
+
+export function createFixPrSession(cwd: string, ledger: FixPrSessionLedger): void {
+  const sessionDir = getSessionDir(cwd, ledger.id);
+  fs.mkdirSync(path.join(sessionDir, "snapshots"), { recursive: true });
+  fs.writeFileSync(path.join(sessionDir, "ledger.json"), JSON.stringify(ledger, null, 2));
+}
+
+export function loadFixPrSession(cwd: string, sessionId: string): FixPrSessionLedger | null {
+  const ledgerPath = path.join(getSessionDir(cwd, sessionId), "ledger.json");
+  if (!fs.existsSync(ledgerPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(ledgerPath, "utf-8")) as FixPrSessionLedger;
+  } catch {
+    return null;
+  }
+}
+
+export function updateFixPrSession(cwd: string, ledger: FixPrSessionLedger): void {
+  const ledgerPath = path.join(getSessionDir(cwd, ledger.id), "ledger.json");
+  ledger.updatedAt = new Date().toISOString();
+  fs.writeFileSync(ledgerPath, JSON.stringify(ledger, null, 2));
+}
+
+export function findActiveFixPrSession(cwd: string): FixPrSessionLedger | null {
+  const baseDir = getBaseDir(cwd);
+  if (!fs.existsSync(baseDir)) return null;
+
+  const dirs = fs.readdirSync(baseDir)
+    .filter((d) => d.startsWith("fpr-"))
+    .sort()
+    .reverse();
+
+  for (const dir of dirs) {
+    const ledger = loadFixPrSession(cwd, dir);
+    if (ledger && ledger.status === "running") return ledger;
+  }
+  return null;
+}

package/src/storage/qa-sessions.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { QaSessionLedger } from "../types.js";
+import type { E2eSessionLedger } from "../qa/types.js";
 
 const SESSIONS_DIR = [".omp", "supipowers", "qa-sessions"];
 
@@ -8,7 +8,7 @@ function getSessionsDir(cwd: string): string {
   return path.join(cwd, ...SESSIONS_DIR);
 }
 
-function getSessionDir(cwd: string, sessionId: string): string {
+export function getSessionDir(cwd: string, sessionId: string): string {
   return path.join(getSessionsDir(cwd), sessionId);
 }
 
@@ -22,17 +22,17 @@ export function generateSessionId(): string {
 }
 
 /** Create a new QA session */
-export function createSession(cwd: string, ledger: QaSessionLedger): void {
+export function createSession(cwd: string, ledger: E2eSessionLedger): void {
   const sessionDir = getSessionDir(cwd, ledger.id);
   fs.mkdirSync(sessionDir, { recursive: true });
   fs.writeFileSync(
     path.join(sessionDir, "ledger.json"),
-    JSON.stringify(ledger, null, 2) + "\n"
+    JSON.stringify(ledger, null, 2) + "\n",
   );
 }
 
 /** Load a QA session ledger */
-export function loadSession(cwd: string, sessionId: string): QaSessionLedger | null {
+export function loadSession(cwd: string, sessionId: string): E2eSessionLedger | null {
   const filePath = path.join(getSessionDir(cwd, sessionId), "ledger.json");
   if (!fs.existsSync(filePath)) return null;
   try {
@@ -43,7 +43,7 @@ export function loadSession(cwd: string, sessionId: string): QaSessionLedger | n
 }
 
 /** Update a QA session ledger */
-export function updateSession(cwd: string, ledger: QaSessionLedger): void {
+export function updateSession(cwd: string, ledger: E2eSessionLedger): void {
   const filePath = path.join(getSessionDir(cwd, ledger.id), "ledger.json");
   fs.writeFileSync(filePath, JSON.stringify(ledger, null, 2) + "\n");
 }
@@ -60,12 +60,12 @@ export function listSessions(cwd: string): string[] {
 }
 
 /** Find the latest session with incomplete phases */
-export function findActiveSession(cwd: string): QaSessionLedger | null {
+export function findActiveSession(cwd: string): E2eSessionLedger | null {
   for (const sessionId of listSessions(cwd)) {
     const ledger = loadSession(cwd, sessionId);
     if (!ledger) continue;
     const allCompleted = Object.values(ledger.phases).every(
-      (p) => p.status === "completed"
+      (p) => p.status === "completed",
     );
     if (!allCompleted) return ledger;
   }
@@ -73,7 +73,7 @@ export function findActiveSession(cwd: string): QaSessionLedger | null {
 }
 
 /** Find the latest session with failed test results */
-export function findSessionWithFailures(cwd: string): QaSessionLedger | null {
+export function findSessionWithFailures(cwd: string): E2eSessionLedger | null {
   for (const sessionId of listSessions(cwd)) {
     const ledger = loadSession(cwd, sessionId);
     if (!ledger) continue;

package/src/types.ts

@@ -118,82 +118,13 @@ export interface SupipowersConfig {
   qa: {
     framework: string | null;
     command: string | null;
+    e2e: boolean;
   };
   release: {
     pipeline: string | null;
   };
 }
 
-// ── QA Session Management ──────────────────────────────────────────
-
-/** QA pipeline phase */
-export type QaPhase = "discovery" | "matrix" | "execution" | "reporting";
-
-/** Phase completion status */
-export type QaPhaseStatus = "pending" | "running" | "completed" | "failed";
-
-/** Per-test result status */
-export type TestResultStatus = "pass" | "fail" | "skip";
-
-/** A discovered test case */
-export interface QaTestCase {
-  id: string;
-  filePath: string;
-  testName: string;
-  suiteName?: string;
-  tags?: string[];
-}
-
-/** Traceability matrix entry — one requirement mapped to its tests */
-export interface QaMatrixEntry {
-  requirement: string;
-  testIds: string[];
-  platforms?: string[];
-  coverage: "full" | "partial" | "none";
-}
-
-/** Per-test execution result */
-export interface QaTestResult {
-  testId: string;
-  status: TestResultStatus;
-  duration?: number;
-  error?: string;
-  retryCount: number;
-  lastRunAt: string;
-}
-
-/** Report summary generated in the Reporting phase */
-export interface QaReportSummary {
-  generatedAt: string;
-  total: number;
-  passed: number;
-  failed: number;
-  skipped: number;
-  passRate: number;
-  failedTests: { testId: string; testName: string; error?: string }[];
-  coverageSummary?: string;
-}
-
-/** Phase record within a session */
-export interface QaPhaseRecord {
-  status: QaPhaseStatus;
-  startedAt?: string;
-  completedAt?: string;
-}
-
-/** The full QA session ledger */
-export interface QaSessionLedger {
-  id: string;
-  createdAt: string;
-  updatedAt: string;
-  framework: string;
-  phases: Record<QaPhase, QaPhaseRecord>;
-  tests: QaTestCase[];
-  matrix: QaMatrixEntry[];
-  results: QaTestResult[];
-  report?: QaReportSummary;
-}
-
 /** Profile shape */
 export interface Profile {
   name: string;

package/src/qa/detector.ts

@@ -1,61 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { updateConfig, loadConfig } from "../config/loader.js";
-
-export interface DetectedFramework {
-  name: string;
-  command: string;
-}
-
-const FRAMEWORK_SIGNATURES: { name: string; files: string[]; command: string }[] = [
-  { name: "vitest", files: ["vitest.config.ts", "vitest.config.js", "vitest.config.mts"], command: "npx vitest run" },
-  { name: "jest", files: ["jest.config.ts", "jest.config.js", "jest.config.mjs"], command: "npx jest" },
-  { name: "mocha", files: [".mocharc.yml", ".mocharc.json", ".mocharc.js"], command: "npx mocha" },
-  { name: "pytest", files: ["pytest.ini", "pyproject.toml", "conftest.py"], command: "pytest" },
-  { name: "cargo-test", files: ["Cargo.toml"], command: "cargo test" },
-  { name: "go-test", files: ["go.mod"], command: "go test ./..." },
-];
-
-export function detectFramework(cwd: string): DetectedFramework | null {
-  const pkgPath = path.join(cwd, "package.json");
-  if (fs.existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
-        const testScript = pkg.scripts.test;
-        for (const sig of FRAMEWORK_SIGNATURES) {
-          if (testScript.includes(sig.name)) {
-            return { name: sig.name, command: "npm test" };
-          }
-        }
-        return { name: "npm-test", command: "npm test" };
-      }
-    } catch {
-      // continue to file-based detection
-    }
-  }
-
-  for (const sig of FRAMEWORK_SIGNATURES) {
-    for (const file of sig.files) {
-      if (fs.existsSync(path.join(cwd, file))) {
-        return { name: sig.name, command: sig.command };
-      }
-    }
-  }
-
-  return null;
-}
-
-export function detectAndCache(cwd: string): DetectedFramework | null {
-  const config = loadConfig(cwd);
-
-  if (config.qa.framework && config.qa.command) {
-    return { name: config.qa.framework, command: config.qa.command };
-  }
-
-  const detected = detectFramework(cwd);
-  if (detected) {
-    updateConfig(cwd, { qa: { framework: detected.name, command: detected.command } });
-  }
-  return detected;
-}

package/src/qa/phases/discovery.ts

@@ -1,34 +0,0 @@
-import type { DetectedFramework } from "../detector.js";
-
-export function buildDiscoveryPrompt(framework: DetectedFramework, cwd: string): string {
-  const sections: string[] = [
-    "# QA Phase: Test Discovery",
-    "",
-    `Project: ${cwd}`,
-    `Test framework: ${framework.name} (command: \`${framework.command}\`)`,
-    "",
-    "## Task",
-    "",
-    "Scan the project for all test files and enumerate every individual test case.",
-    "",
-    "1. Find all test files matching the framework's conventions",
-    "2. Parse each file to extract individual test/it/describe blocks",
-    "3. Classify each test with tags (unit, integration, e2e) based on file path or naming",
-    "",
-    "## Expected Output",
-    "",
-    "Write a JSON array to the QA session ledger's `tests` field. Each entry:",
-    "",
-    "```json",
-    '[{ "id": "<filePath>:<testName>", "filePath": "relative/path.test.ts", "testName": "test name", "suiteName": "describe block", "tags": ["unit"] }]',
-    "```",
-    "",
-    "The `id` must be deterministic: use `filePath:testName` so it stays stable across sessions.",
-    "",
-    "## After Completion",
-    "",
-    "Update the QA session ledger with the discovered tests, mark the discovery phase as completed, then invoke `/supi:qa` to continue to the next phase.",
-  ];
-
-  return sections.join("\n");
-}

package/src/qa/phases/execution.ts

@@ -1,65 +0,0 @@
-import type { QaSessionLedger, QaTestCase } from "../../types.js";
-
-export interface ExecutionOptions {
-  failedOnly: true;
-  failedTests: QaTestCase[];
-}
-
-export function buildExecutionPrompt(
-  ledger: QaSessionLedger,
-  options?: ExecutionOptions
-): string {
-  const isRetry = options?.failedOnly === true;
-  const targetTests = isRetry ? options.failedTests : ledger.tests;
-
-  const testList = targetTests
-    .map((t) => `- ${t.id}: ${t.testName} (${t.filePath})`)
-    .join("\n");
-
-  const sections: string[] = [
-    "# QA Phase: Test Execution",
-    "",
-    `Framework: ${ledger.framework}`,
-  ];
-
-  if (isRetry) {
-    sections.push(
-      "",
-      `## Re-running ${targetTests.length} failed test(s)`,
-      "",
-      "Run ONLY the following failed tests:",
-      "",
-      testList,
-    );
-  } else {
-    sections.push(
-      "",
-      `## Running all ${targetTests.length} test(s)`,
-      "",
-      testList,
-    );
-  }
-
-  sections.push(
-    "",
-    "## Instructions",
-    "",
-    "1. Run the tests using the framework's CLI",
-    "2. Collect per-test results: pass, fail, or skip",
-    "3. For failures, capture the error message",
-    "",
-    "## Expected Output",
-    "",
-    "Write a JSON array to the QA session ledger's `results` field:",
-    "",
-    "```json",
-    '[{ "testId": "file.test.ts:test name", "status": "pass|fail|skip", "duration": 123, "error": "only if failed" }]',
-    "```",
-    "",
-    "## After Completion",
-    "",
-    "Update the QA session ledger with results, mark the execution phase as completed, then invoke `/supi:qa` to continue to the next phase.",
-  );
-
-  return sections.join("\n");
-}

package/src/qa/phases/matrix.ts

@@ -1,41 +0,0 @@
-import type { QaSessionLedger } from "../../types.js";
-
-export function buildMatrixPrompt(ledger: QaSessionLedger): string {
-  const testSummary = ledger.tests
-    .map((t) => `- ${t.id}: ${t.testName} (${t.filePath})${t.tags ? ` [${t.tags.join(", ")}]` : ""}`)
-    .join("\n");
-
-  const sections: string[] = [
-    "# QA Phase: Traceability Matrix",
-    "",
-    `Framework: ${ledger.framework}`,
-    `Discovered tests: ${ledger.tests.length}`,
-    "",
-    "## Discovered Tests",
-    "",
-    testSummary,
-    "",
-    "## Task",
-    "",
-    "Build a traceability matrix that maps requirements to test cases and platforms.",
-    "",
-    "1. Read the project's README, PR descriptions, code comments, and doc files to identify requirements",
-    "2. Map each requirement to the test case IDs that cover it",
-    "3. Identify target platforms (node, browser, CI) from project config",
-    "4. Assess coverage: full (all paths tested), partial (some paths), none (no tests)",
-    "",
-    "## Expected Output",
-    "",
-    "Write a JSON array to the QA session ledger's `matrix` field:",
-    "",
-    "```json",
-    '[{ "requirement": "User login validates email format", "testIds": ["auth.test.ts:validates email"], "platforms": ["node"], "coverage": "full" }]',
-    "```",
-    "",
-    "## After Completion",
-    "",
-    "Update the QA session ledger with the matrix, mark the matrix phase as completed, then invoke `/supi:qa` to continue to the next phase.",
-  ];
-
-  return sections.join("\n");
-}