supipowers 1.5.2 → 2.0.0

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

@@ -0,0 +1,226 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { findExecutable } from "../../utils/executable.js";
+
+interface PlaywrightResultEntry {
+  test: string;
+  file: string;
+  status: string;
+  duration: number;
+  error: string | null;
+}
+
+interface PlaywrightSummary {
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  duration: number;
+  failures: Array<{
+    test: string;
+    file: string;
+    error: string;
+  }>;
+  error?: string;
+}
+
+function quoteCmdArgument(arg: string): string {
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+
+function spawnPlaywright(
+  playwrightBinary: string,
+  playwrightArgs: string[],
+  cwd: string,
+  baseUrl: string,
+  env: NodeJS.ProcessEnv,
+  encoding: BufferEncoding,
+ ) {
+  const spawnOptions = {
+    cwd,
+    env: { ...env, BASE_URL: baseUrl },
+    encoding,
+  } as const;
+
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(playwrightBinary)) {
+    const commandLine = [playwrightBinary, ...playwrightArgs].map(quoteCmdArgument).join(" ");
+    return spawnSync("cmd.exe", ["/d", "/s", "/c", commandLine], spawnOptions);
+  }
+
+  return spawnSync(playwrightBinary, playwrightArgs, spawnOptions);
+}
+
+function resolvePlaywrightBinary(cwd: string): string | null {
+  return findExecutable("playwright-cli", {
+    cwd,
+    localDirs: [path.join("node_modules", ".bin")],
+    preferLocal: true,
+  });
+}
+
+function collectTestResults(suite: any, parentTitle: string, results: PlaywrightResultEntry[]): void {
+  const suiteTitle = typeof suite?.title === "string" && suite.title.length > 0
+    ? (parentTitle ? `${parentTitle} > ${suite.title}` : suite.title)
+    : parentTitle;
+
+  for (const spec of Array.isArray(suite?.specs) ? suite.specs : []) {
+    const specTitle = typeof spec?.title === "string" && spec.title.length > 0
+      ? `${suiteTitle} > ${spec.title}`
+      : suiteTitle;
+    const file = `${spec?.file ?? ""}${spec?.line ? `:${spec.line}` : ""}`;
+
+    for (const test of Array.isArray(spec?.tests) ? spec.tests : []) {
+      for (const result of Array.isArray(test?.results) ? test.results : []) {
+        results.push({
+          test: specTitle,
+          file,
+          status: String(result?.status ?? "unknown"),
+          duration: Number(result?.duration ?? 0),
+          error: result?.error?.message ?? null,
+        });
+      }
+    }
+  }
+
+  for (const child of Array.isArray(suite?.suites) ? suite.suites : []) {
+    collectTestResults(child, suiteTitle, results);
+  }
+}
+
+export function summarizePlaywrightOutput(raw: string): PlaywrightSummary {
+  const parsed = JSON.parse(raw);
+  const results: PlaywrightResultEntry[] = [];
+
+  for (const suite of Array.isArray(parsed?.suites) ? parsed.suites : []) {
+    collectTestResults(suite, "", results);
+  }
+
+  const passed = results.filter((result) => result.status === "passed").length;
+  const failed = results.filter((result) => result.status === "failed" || result.status === "timedOut").length;
+  const skipped = results.filter((result) => result.status === "skipped").length;
+  const duration = results.reduce((sum, result) => sum + result.duration, 0);
+  const failures = results
+    .filter((result) => result.status === "failed" || result.status === "timedOut")
+    .map((result) => ({
+      test: result.test,
+      file: result.file,
+      error: result.error ?? "Unknown error",
+    }));
+
+  return {
+    total: results.length,
+    passed,
+    failed,
+    skipped,
+    duration,
+    failures,
+  };
+}
+
+function buildErrorSummary(message: string): PlaywrightSummary {
+  return {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    duration: 0,
+    failures: [],
+    error: message,
+  };
+}
+
+export function runE2eTests(
+  testDir: string,
+  baseUrl: string,
+  testFilter: string,
+  cwd: string,
+): { exitCode: number; stdout: string } {
+  const resultsDir = path.resolve(testDir, "..", "results");
+  fs.mkdirSync(resultsDir, { recursive: true });
+
+  const rawOutputPath = path.join(resultsDir, "raw-results.json");
+  const playwrightStderrPath = path.join(resultsDir, "playwright-stderr.log");
+  const summaryPath = path.join(resultsDir, "summary.json");
+  const nodeParseStderrPath = path.join(resultsDir, "node-parse-stderr.log");
+
+  const playwrightBinary = resolvePlaywrightBinary(cwd);
+  if (!playwrightBinary) {
+    const stdout = JSON.stringify(
+      buildErrorSummary("playwright not found. Install with: npm install -g @playwright/cli@latest"),
+    );
+    return { exitCode: 1, stdout };
+  }
+
+  const playwrightArgs = [
+    "test",
+    testDir,
+    "--reporter=json",
+    `--output=${resultsDir}`,
+  ];
+
+  if (testFilter.length > 0) {
+    playwrightArgs.push("--grep", testFilter);
+  }
+
+  const result = spawnPlaywright(
+    playwrightBinary,
+    playwrightArgs,
+    cwd,
+    baseUrl,
+    process.env,
+    "utf8",
+  );
+
+  const rawOutput = result.stdout ?? "";
+  const stderrOutput = result.stderr ?? "";
+  fs.writeFileSync(rawOutputPath, rawOutput);
+  fs.writeFileSync(playwrightStderrPath, stderrOutput);
+
+  if (rawOutput.trim().length === 0) {
+    const stdout = JSON.stringify(
+      buildErrorSummary(
+        `playwright produced no output (exit code: ${result.status ?? 1}). See ${playwrightStderrPath} for details.`,
+      ),
+    );
+    return { exitCode: 1, stdout };
+  }
+
+  try {
+    const summary = summarizePlaywrightOutput(rawOutput);
+    const stdout = JSON.stringify(summary);
+    fs.writeFileSync(summaryPath, stdout);
+    return {
+      exitCode: summary.failed > 0 ? 2 : 0,
+      stdout,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    fs.writeFileSync(nodeParseStderrPath, message);
+    const stdout = JSON.stringify(
+      buildErrorSummary(`Failed to parse playwright output. See ${nodeParseStderrPath} for details.`),
+    );
+    return { exitCode: 1, stdout };
+  }
+}
+
+function main(): void {
+  const [testDir, baseUrl, testFilter = ""] = process.argv.slice(2);
+  if (!testDir || !baseUrl) {
+    const stdout = JSON.stringify(
+      buildErrorSummary("Usage: run-e2e-tests.ts <test_dir> <base_url> [test_filter]"),
+    );
+    console.log(stdout);
+    process.exit(1);
+  }
+
+  const result = runE2eTests(testDir, baseUrl, testFilter, process.cwd());
+  console.log(result.stdout);
+  process.exit(result.exitCode);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main();
+}

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

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import {
+  DEV_SERVER_PID_FILENAME,
+  getShellInvocation,
+  isServerReachable,
+  killProcessTree,
+} from "./dev-server-utils.js";
+
+export interface StartDevServerResult {
+  pid: number | null;
+  url: string;
+  ready: boolean;
+  note?: string;
+  error?: string;
+}
+
+function buildResult(result: StartDevServerResult): string {
+  return JSON.stringify(result);
+}
+
+export async function startDevServer(
+  cwd: string,
+  devCommand: string,
+  port: number,
+  timeoutSeconds: number,
+  sessionDir: string,
+): Promise<{ exitCode: number; output: string }> {
+  const url = `http://localhost:${port}`;
+  if (await isServerReachable(port)) {
+    return {
+      exitCode: 0,
+      output: buildResult({
+        pid: null,
+        url,
+        ready: true,
+        note: "Server already running",
+      }),
+    };
+  }
+
+  fs.mkdirSync(sessionDir, { recursive: true });
+  const pidFile = path.join(sessionDir, DEV_SERVER_PID_FILENAME);
+  const logPath = path.join(sessionDir, "dev-server.log");
+  const logFd = fs.openSync(logPath, "a");
+  const shell = getShellInvocation(devCommand);
+  const child = spawn(shell.command, shell.args, {
+    cwd,
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: process.env,
+  });
+  child.unref();
+  fs.closeSync(logFd);
+
+  if (!child.pid) {
+    return {
+      exitCode: 1,
+      output: buildResult({
+        pid: null,
+        url,
+        ready: false,
+        error: "Dev server failed to start",
+      }),
+    };
+  }
+
+  fs.writeFileSync(pidFile, String(child.pid));
+
+  for (let attempt = 0; attempt < timeoutSeconds; attempt += 1) {
+    if (child.exitCode !== null) {
+      fs.rmSync(pidFile, { force: true });
+      return {
+        exitCode: 1,
+        output: buildResult({
+          pid: child.pid,
+          url,
+          ready: false,
+          error: "Server process exited",
+        }),
+      };
+    }
+
+    if (await isServerReachable(port)) {
+      return {
+        exitCode: 0,
+        output: buildResult({
+          pid: child.pid,
+          url,
+          ready: true,
+        }),
+      };
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1_000));
+  }
+
+  await killProcessTree(child.pid);
+  fs.rmSync(pidFile, { force: true });
+  return {
+    exitCode: 1,
+    output: buildResult({
+      pid: child.pid,
+      url,
+      ready: false,
+      error: `Timeout after ${timeoutSeconds}s`,
+    }),
+  };
+}
+
+async function main(): Promise<void> {
+  const [cwd, devCommand, portArg, timeoutArg = "60", sessionDir = "."] = process.argv.slice(2);
+  const port = Number.parseInt(portArg ?? "", 10);
+  const timeoutSeconds = Number.parseInt(timeoutArg, 10);
+
+  if (!cwd || !devCommand || !Number.isInteger(port) || !Number.isInteger(timeoutSeconds)) {
+    console.log(
+      buildResult({
+        pid: null,
+        url: Number.isInteger(port) ? `http://localhost:${port}` : "http://localhost:0",
+        ready: false,
+        error: "Usage: start-dev-server.ts <cwd> <dev_command> <port> <timeout_seconds> <session_dir>",
+      }),
+    );
+    process.exit(1);
+  }
+
+  const result = await startDevServer(cwd, devCommand, port, timeoutSeconds, sessionDir);
+  console.log(result.output);
+  process.exit(result.exitCode);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  void main();
+}

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

@@ -0,0 +1,77 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  DEV_SERVER_PID_FILENAME,
+  killProcessTree,
+  processExists,
+} from "./dev-server-utils.js";
+
+export interface StopDevServerResult {
+  stopped: boolean;
+  pid?: number;
+  note?: string;
+  error?: string;
+}
+
+function buildResult(result: StopDevServerResult): string {
+  return JSON.stringify(result);
+}
+
+export async function stopDevServer(sessionDir: string): Promise<{ exitCode: number; output: string }> {
+  const pidFile = path.join(sessionDir, DEV_SERVER_PID_FILENAME);
+  if (!fs.existsSync(pidFile)) {
+    return {
+      exitCode: 0,
+      output: buildResult({ stopped: false, error: "No PID file found" }),
+    };
+  }
+
+  const pidText = fs.readFileSync(pidFile, "utf8").trim();
+  if (pidText.length === 0) {
+    return {
+      exitCode: 0,
+      output: buildResult({ stopped: false, error: "Empty PID file" }),
+    };
+  }
+
+  const pid = Number.parseInt(pidText, 10);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    fs.rmSync(pidFile, { force: true });
+    return {
+      exitCode: 0,
+      output: buildResult({ stopped: false, error: `Invalid PID file: ${pidText}` }),
+    };
+  }
+
+  if (!processExists(pid)) {
+    fs.rmSync(pidFile, { force: true });
+    return {
+      exitCode: 0,
+      output: buildResult({
+        stopped: true,
+        pid,
+        note: "Process was already dead",
+      }),
+    };
+  }
+
+  await killProcessTree(pid);
+  fs.rmSync(pidFile, { force: true });
+  return {
+    exitCode: 0,
+    output: buildResult({ stopped: true, pid }),
+  };
+}
+
+async function main(): Promise<void> {
+  const [sessionDir = "."] = process.argv.slice(2);
+  const result = await stopDevServer(sessionDir);
+  console.log(result.output);
+  process.exit(result.exitCode);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  void main();
+}

package/src/qa/session.ts

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { E2ePhase, E2ePhaseStatus, E2eSessionLedger, E2eQaConfig } from "./types.js";
 import type { PlatformPaths } from "../platform/types.js";
-import { generateSessionId, createSession, updateSession } from "../storage/qa-sessions.js";
+import type { WorkspaceTarget } from "../types.js";
+import { createSession, generateSessionId, getSessionDir, updateSession } from "../storage/qa-sessions.js";
+import type { E2ePhase, E2ePhaseStatus, E2eQaConfig, E2eSessionLedger } from "./types.js";
 
 const PHASE_ORDER: E2ePhase[] = ["flow-discovery", "test-generation", "execution", "reporting"];
 
@@ -14,7 +15,12 @@ const PHASE_LABELS: Record<E2ePhase, string> = {
 };
 
 /** Create a new E2E QA session with all phases pending */
-export function createNewE2eSession(paths: PlatformPaths, cwd: string, config: E2eQaConfig): E2eSessionLedger {
+export function createNewE2eSession(
+  paths: PlatformPaths,
+  cwd: string,
+  config: E2eQaConfig,
+  target?: WorkspaceTarget,
+): E2eSessionLedger {
   const now = new Date().toISOString();
   const ledger: E2eSessionLedger = {
     id: generateSessionId(),
@@ -34,10 +40,9 @@ export function createNewE2eSession(paths: PlatformPaths, cwd: string, config: E
     config,
   };
 
-  // Create session with subdirectories
-  createSession(paths, cwd, ledger);
+  createSession(paths, cwd, ledger, target);
 
-  const sessionDir = paths.project(cwd, "qa-sessions", ledger.id);
+  const sessionDir = getSessionDir(paths, cwd, ledger.id, target);
   fs.mkdirSync(path.join(sessionDir, "tests"), { recursive: true });
   fs.mkdirSync(path.join(sessionDir, "screenshots"), { recursive: true });
 
@@ -51,6 +56,7 @@ export function advanceE2ePhase(
   ledger: E2eSessionLedger,
   phase: E2ePhase,
   status: E2ePhaseStatus,
+  target?: WorkspaceTarget,
 ): E2eSessionLedger {
   const now = new Date().toISOString();
   const record = { ...ledger.phases[phase] };
@@ -68,7 +74,7 @@ export function advanceE2ePhase(
     updatedAt: now,
     phases: { ...ledger.phases, [phase]: record },
   };
-  updateSession(paths, cwd, updated);
+  updateSession(paths, cwd, updated, target);
   return updated;
 }
 

package/src/quality/ai-setup.ts

@@ -1,11 +1,11 @@
 import { loadModelConfig } from "../config/model-config.js";
 import { modelRegistry } from "../config/model-registry-instance.js";
 import { createModelBridge, resolveModelForAction } from "../config/model-resolver.js";
-import { validateQualityGates } from "../config/schema.js";
-import { stripMarkdownCodeFence } from "../text.js";
+import { renderSchemaText } from "../ai/schema-text.js";
+import { parseStructuredOutput, runWithOutputValidation } from "../ai/structured-output.js";
+import { QualityGatesSchema } from "./schemas.js";
 import type { Platform } from "../platform/types.js";
 import type { ProjectFacts, QualityGatesConfig, SetupProposal } from "../types.js";
-import { runStructuredAgentSession } from "./ai-session.js";
 
 modelRegistry.register({
   id: "quality-gate-setup",
@@ -14,21 +14,22 @@ modelRegistry.register({
   harnessRoleHint: "slow",
 });
 
-function buildAiSetupPrompt(projectFacts: ProjectFacts, proposal: SetupProposal): string {
+const QUALITY_GATES_SCHEMA_TEXT = renderSchemaText(QualityGatesSchema);
+
+export function buildAiSetupPrompt(projectFacts: ProjectFacts, proposal: SetupProposal): string {
   return [
     "You are configuring Supipowers review quality gates for a repository.",
-    "Return JSON only as a QualityGatesConfig object.",
-    "",
-    "Available gates and shapes:",
-    '- "lsp-diagnostics": {"enabled": true|false}',
-    '- "lint": {"enabled": true, "command": "..."} or {"enabled": false}',
-    '- "typecheck": {"enabled": true, "command": "..."} or {"enabled": false}',
-    '- "format": {"enabled": true, "command": "..."} or {"enabled": false}',
-    '- "test-suite": {"enabled": true, "command": "..."} or {"enabled": false}',
-    '- "build": {"enabled": true, "command": "..."} or {"enabled": false}',
+    "Return JSON only as a QualityGatesConfig object matching this schema:",
+    QUALITY_GATES_SCHEMA_TEXT,
     "",
     "Rules:",
     "- Prefer commands that already exist in package.json scripts.",
+    "- Command-driven gates must use canonical target-aware runs. When enabled, return runs with command + target selectors instead of a single command string.",
+    "- packageScripts contains only commands shared across every discovered target; use targets to inspect package-specific scripts.",
+    "- /supi:checks All must cover the root target and every workspace target deterministically.",
+    "- /supi:checks runs commands from each target's package root, so add target-specific runs when root/shared commands do not cover a package.",
+    "- Use target.scope all-targets only when the same command truly works for every target.",
+    "- Use target.scope root, all-workspaces, or workspace with relativeDir when coverage differs by target.",
     "- Never invent a mutating format command such as --write or lint --fix.",
     "- Prefer checks that verify correctness during review: lsp, lint, typecheck, format check, tests, and build.",
     "- Keep deterministic suggestions unless you have repository evidence to improve them.",
@@ -40,17 +41,11 @@ function buildAiSetupPrompt(projectFacts: ProjectFacts, proposal: SetupProposal)
     "",
     "Deterministic baseline proposal:",
     JSON.stringify(proposal.gates, null, 2),
+    ...(proposal.notes && proposal.notes.length > 0
+      ? ["", "Deterministic baseline notes:", ...proposal.notes.map((note) => `- ${note}`)]
+      : []),
   ].join("\n");
-}
-
-function parseAiSetupSuggestion(raw: string): QualityGatesConfig {
-  const parsed = JSON.parse(stripMarkdownCodeFence(raw)) as QualityGatesConfig;
-  const validation = validateQualityGates(parsed);
-  if (!validation.valid) {
-    throw new Error(validation.errors.join("\n"));
-  }
 
-  return parsed;
 }
 
 export async function suggestQualityGatesWithAi(input: {
@@ -67,20 +62,27 @@ export async function suggestQualityGatesWithAi(input: {
     createModelBridge(input.platform),
   );
 
-  const result = await runStructuredAgentSession(
+  const result = await runWithOutputValidation<QualityGatesConfig>(
     input.platform.createAgentSession.bind(input.platform),
     {
       cwd: input.cwd,
       prompt: buildAiSetupPrompt(input.projectFacts, input.proposal),
+      schema: QUALITY_GATES_SCHEMA_TEXT,
+      parse: (raw) => parseStructuredOutput<QualityGatesConfig>(raw, QualityGatesSchema),
       model: resolvedModel.model,
       thinkingLevel: resolvedModel.thinkingLevel,
       timeoutMs: 120_000,
+      reliability: {
+        paths: input.platform.paths,
+        cwd: input.cwd,
+        command: "quality-setup",
+      },
     },
   );
 
-  if (result.status !== "ok") {
+  if (result.status === "blocked") {
     throw new Error(result.error);
   }
 
-  return parseAiSetupSuggestion(result.finalText);
+  return result.output;
 }

package/src/quality/contracts.ts

@@ -0,0 +1,34 @@
+// src/quality/contracts.ts
+//
+// TypeBox contracts for AI-driven quality-gate workflows. Embedded into
+// prompts via ai/schema-text.ts and used by ai/structured-output.ts to
+// validate model output with retry-on-invalid feedback.
+
+import { Type, type Static } from "@sinclair/typebox";
+
+const ISSUE_SEVERITIES = ["error", "warning", "info"] as const;
+const RECOMMENDED_STATUSES = ["passed", "failed", "blocked"] as const;
+
+export const AiReviewIssueSchema = Type.Object(
+  {
+    severity: Type.Union(ISSUE_SEVERITIES.map((value) => Type.Literal(value))),
+    message: Type.String({ minLength: 1 }),
+    file: Type.Optional(Type.String()),
+    line: Type.Optional(Type.Number()),
+    detail: Type.Optional(Type.String()),
+  },
+  { additionalProperties: false },
+);
+
+export const AiReviewOutputSchema = Type.Object(
+  {
+    summary: Type.String(),
+    issues: Type.Array(AiReviewIssueSchema),
+    recommendedStatus: Type.Union(
+      RECOMMENDED_STATUSES.map((value) => Type.Literal(value)),
+    ),
+  },
+  { additionalProperties: false },
+);
+
+export type AiReviewOutput = Static<typeof AiReviewOutputSchema>;