supipowers 0.4.0 → 0.6.0

package/src/qa/scripts/run-e2e-tests.sh

@@ -0,0 +1,99 @@
+#!/usr/bin/env bash
+# Run playwright tests and produce a compact JSON summary.
+# Usage: run-e2e-tests.sh <test_dir> <base_url> [test_filter]
+# Output: Compact JSON summary on stdout
+set -euo pipefail
+
+TEST_DIR="$1"
+BASE_URL="$2"
+TEST_FILTER="${3:-}"
+RESULTS_DIR="${TEST_DIR}/../results"
+SCREENSHOTS_DIR="${TEST_DIR}/../screenshots"
+
+mkdir -p "$RESULTS_DIR" "$SCREENSHOTS_DIR"
+
+# Build playwright command
+PW_ARGS=(
+  test
+  "$TEST_DIR"
+  --reporter=json
+  --output="$RESULTS_DIR"
+)
+
+if [ -n "$TEST_FILTER" ]; then
+  PW_ARGS+=(--grep "$TEST_FILTER")
+fi
+
+# Run playwright, capture JSON output
+RAW_OUTPUT="$RESULTS_DIR/raw-results.json"
+set +e
+BASE_URL="$BASE_URL" npx playwright "${PW_ARGS[@]}" > "$RAW_OUTPUT" 2>/dev/null
+PW_EXIT=$?
+set -e
+
+# If no JSON output was produced, create a minimal error report
+if [ ! -s "$RAW_OUTPUT" ]; then
+  cat <<EOF
+{"total": 0, "passed": 0, "failed": 0, "skipped": 0, "duration": 0, "failures": [], "error": "Playwright produced no output (exit code: $PW_EXIT)"}
+EOF
+  exit 0
+fi
+
+# Parse the JSON output into compact summary using node (more reliable than jq)
+node -e "
+const fs = require('fs');
+const raw = JSON.parse(fs.readFileSync('$RAW_OUTPUT', 'utf-8'));
+
+const suites = raw.suites || [];
+const results = [];
+
+function collectTests(suite, parentTitle) {
+  const title = parentTitle ? parentTitle + ' > ' + suite.title : suite.title;
+  for (const spec of (suite.specs || [])) {
+    for (const test of (spec.tests || [])) {
+      for (const result of (test.results || [])) {
+        results.push({
+          test: title + ' > ' + spec.title,
+          file: spec.file + (spec.line ? ':' + spec.line : ''),
+          status: result.status,
+          duration: result.duration || 0,
+          error: result.error?.message || null,
+        });
+      }
+    }
+  }
+  for (const child of (suite.suites || [])) {
+    collectTests(child, title);
+  }
+}
+
+for (const suite of suites) {
+  collectTests(suite, '');
+}
+
+const passed = results.filter(r => r.status === 'passed').length;
+const failed = results.filter(r => r.status === 'failed' || r.status === 'timedOut').length;
+const skipped = results.filter(r => r.status === 'skipped').length;
+const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+
+const failures = results
+  .filter(r => r.status === 'failed' || r.status === 'timedOut')
+  .map(r => ({
+    test: r.test,
+    file: r.file,
+    error: r.error || 'Unknown error',
+  }));
+
+const summary = {
+  total: results.length,
+  passed,
+  failed,
+  skipped,
+  duration: totalDuration,
+  failures,
+};
+
+console.log(JSON.stringify(summary));
+" 2>/dev/null || cat <<EOF
+{"total": 0, "passed": 0, "failed": 0, "skipped": 0, "duration": 0, "failures": [], "error": "Failed to parse playwright output"}
+EOF

package/src/qa/scripts/start-dev-server.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+# Start the dev server in the background and wait for it to be ready.
+# Usage: start-dev-server.sh <cwd> <dev_command> <port> <timeout_seconds> <session_dir>
+# Output: JSON on stdout
+set -euo pipefail
+
+CWD="$1"
+DEV_COMMAND="$2"
+PORT="$3"
+TIMEOUT="${4:-60}"
+SESSION_DIR="${5:-.}"
+
+cd "$CWD"
+
+# Check if port is already in use
+if curl -s -o /dev/null -w "%{http_code}" "http://localhost:$PORT" 2>/dev/null | grep -qE '^[0-9]'; then
+  echo "{\"pid\": null, \"url\": \"http://localhost:$PORT\", \"ready\": true, \"note\": \"Server already running\"}"
+  exit 0
+fi
+
+# Start dev server in background
+eval "$DEV_COMMAND" > "$SESSION_DIR/dev-server.log" 2>&1 &
+PID=$!
+echo "$PID" > "$SESSION_DIR/dev-server.pid"
+
+# Wait for server to be ready
+for i in $(seq 1 "$TIMEOUT"); do
+  # Check if process is still alive
+  if ! kill -0 "$PID" 2>/dev/null; then
+    echo "{\"pid\": $PID, \"url\": \"http://localhost:$PORT\", \"ready\": false, \"error\": \"Server process exited\"}"
+    exit 1
+  fi
+
+  # Check if port responds
+  if curl -s -o /dev/null "http://localhost:$PORT" 2>/dev/null; then
+    echo "{\"pid\": $PID, \"url\": \"http://localhost:$PORT\", \"ready\": true}"
+    exit 0
+  fi
+
+  sleep 1
+done
+
+# Timeout — kill the server
+kill "$PID" 2>/dev/null || true
+echo "{\"pid\": $PID, \"url\": \"http://localhost:$PORT\", \"ready\": false, \"error\": \"Timeout after ${TIMEOUT}s\"}"
+exit 1

package/src/qa/scripts/stop-dev-server.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Stop the dev server started by start-dev-server.sh.
+# Usage: stop-dev-server.sh <session_dir>
+set -euo pipefail
+
+SESSION_DIR="${1:-.}"
+PID_FILE="$SESSION_DIR/dev-server.pid"
+
+if [ ! -f "$PID_FILE" ]; then
+  echo '{"stopped": false, "error": "No PID file found"}'
+  exit 0
+fi
+
+PID=$(cat "$PID_FILE")
+
+if [ -z "$PID" ]; then
+  echo '{"stopped": false, "error": "Empty PID file"}'
+  exit 0
+fi
+
+# Kill the process and its children
+if kill -0 "$PID" 2>/dev/null; then
+  # Kill process group if possible
+  kill -- -"$PID" 2>/dev/null || kill "$PID" 2>/dev/null || true
+  # Wait briefly for cleanup
+  sleep 1
+  # Force kill if still alive
+  if kill -0 "$PID" 2>/dev/null; then
+    kill -9 "$PID" 2>/dev/null || true
+  fi
+  rm -f "$PID_FILE"
+  echo "{\"stopped\": true, \"pid\": $PID}"
+else
+  rm -f "$PID_FILE"
+  echo "{\"stopped\": true, \"pid\": $PID, \"note\": \"Process was already dead\"}"
+fi

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/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

@@ -99,6 +99,26 @@ export interface ReviewReport {
   passed: boolean;
 }
 
+/** Context-mode integration settings */
+export interface ContextModeConfig {
+  /** Master toggle for all context-mode integration (default: true) */
+  enabled: boolean;
+  /** Byte threshold above which tool results are compressed (default: 4096) */
+  compressionThreshold: number;
+  /** Block curl/wget/HTTP commands and redirect to ctx_fetch_and_index (default: true) */
+  blockHttpCommands: boolean;
+  /** Inject routing instructions into system prompt when ctx_* tools detected (default: true) */
+  routingInstructions: boolean;
+  /** Track events from tool results in SQLite (default: true) */
+  eventTracking: boolean;
+  /** Inject session knowledge into compaction summaries (default: true) */
+  compaction: boolean;
+  /** Use LLM calls for summarizing very large outputs (default: false) */
+  llmSummarization: boolean;
+  /** Byte threshold above which LLM summarization is used instead of structural compression (default: 16384) */
+  llmThreshold: number;
+}
+
 /** Config shape */
 export interface SupipowersConfig {
   version: string;
@@ -118,80 +138,12 @@ 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;
+  contextMode: ContextModeConfig;
 }
 
 /** Profile shape */

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;
-}