@elench/testkit 0.1.79 → 0.1.81

package/lib/cli/presentation/run-reporter.test.mjs

@@ -3,17 +3,29 @@ import figures from "figures";
 import { describe, expect, it } from "vitest";
 import { createRunReporter } from "./run-reporter.mjs";
 
+function createCapture(columns = 100) {
+  let stdout = "";
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      stdout += chunk.toString();
+      callback();
+    },
+  });
+  stream.columns = columns;
+  return {
+    stream,
+    read() {
+      return stdout;
+    },
+  };
+}
+
 describe("run reporter setup output", () => {
   it("prints concise high-level setup summaries in compact mode", () => {
-    let stdout = "";
+    const capture = createCapture();
     const reporter = createRunReporter({
       outputMode: "compact",
-      stdout: new Writable({
-        write(chunk, _encoding, callback) {
-          stdout += chunk.toString();
-          callback();
-        },
-      }),
+      stdout: capture.stream,
     });
 
     reporter.setupOperationFinished({
@@ -25,20 +37,15 @@ describe("run reporter setup output", () => {
       durationMs: 8_000,
     });
 
-    expect(stdout).toContain(`${figures.play} RUN SETUP api template rebuild`);
-    expect(stdout).toContain("8s");
+    expect(capture.read()).toContain(`${figures.play} RUN SETUP api template rebuild`);
+    expect(capture.read()).toContain("8s");
   });
 
   it("does not print low-level setup steps in compact mode", () => {
-    let stdout = "";
+    const capture = createCapture();
     const reporter = createRunReporter({
       outputMode: "compact",
-      stdout: new Writable({
-        write(chunk, _encoding, callback) {
-          stdout += chunk.toString();
-          callback();
-        },
-      }),
+      stdout: capture.stream,
     });
 
     reporter.setupOperationFinished({
@@ -50,19 +57,14 @@ describe("run reporter setup output", () => {
       durationMs: 8_000,
     });
 
-    expect(stdout).toBe("");
+    expect(capture.read()).toBe("");
   });
 
   it("prints concise setup failures", () => {
-    let stdout = "";
+    const capture = createCapture();
     const reporter = createRunReporter({
       outputMode: "compact",
-      stdout: new Writable({
-        write(chunk, _encoding, callback) {
-          stdout += chunk.toString();
-          callback();
-        },
-      }),
+      stdout: capture.stream,
     });
 
     reporter.setupOperationFinished({
@@ -75,7 +77,116 @@ describe("run reporter setup output", () => {
       error: "Command failed with exit code 1: node scripts/fail-prepare.mjs",
     });
 
-    expect(stdout).toContain(`${figures.cross} FAIL SETUP api runtime:prepare`);
-    expect(stdout).toContain("Command failed with exit code 1");
+    expect(capture.read()).toContain(`${figures.cross} FAIL SETUP api runtime:prepare`);
+    expect(capture.read()).toContain("Command failed with exit code 1");
+  });
+});
+
+describe("run reporter task output", () => {
+  it("prints failure details on lines beneath the failed file result", () => {
+    const capture = createCapture(88);
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: capture.stream,
+    });
+
+    reporter.setTotalFileCount(3);
+    reporter.taskFinished(
+      {
+        serviceName: "api",
+        type: "integration",
+        framework: "k6",
+        file: "__testkit__/health/health.int.testkit.ts",
+      },
+      {
+        status: "failed",
+        failed: true,
+        durationMs: 4_000,
+        error: "Default runtime thresholds failed: checks(rate==1.0)",
+        failureDetails: [
+          {
+            kind: "http-assertion",
+            title: "status is 200",
+            message: "GET /health expected 200, got 404",
+            request: {
+              method: "GET",
+              path: "/health",
+              requestId: "req-1",
+            },
+            response: {
+              status: 404,
+              bodyPreview: '{"error":"route not found"}',
+            },
+          },
+        ],
+      }
+    );
+
+    const lines = capture.read().trimEnd().split("\n");
+    expect(lines[0]).toContain("[1/3]");
+    expect(lines[0]).toContain(`${figures.cross} FAIL api int __testkit__/health/health.int.testkit.ts 4s`);
+    expect(lines[1]).toBe("    GET /health expected 200, got 404");
+    expect(lines[2]).toContain('    response: {"error":"route not found"}');
+    expect(lines[3]).toBe("    regression: new");
+    expect(lines[4]).toBe("    logs: requestId=req-1");
+  });
+
+  it("renders a compact aggregate summary box", () => {
+    const capture = createCapture(72);
+    const reporter = createRunReporter({
+      outputMode: "compact",
+      stdout: capture.stream,
+    });
+
+    reporter.runSummary(
+      [
+        {
+          name: "api",
+          skipped: false,
+          failed: true,
+          suiteCount: 1,
+          completedSuiteCount: 1,
+          skippedSuiteCount: 0,
+          failedSuiteCount: 1,
+          totalFileCount: 3,
+          passedFileCount: 2,
+          failedFileCount: 1,
+          skippedFileCount: 0,
+          notRunFileCount: 0,
+          durationMs: 10_000,
+          suites: [],
+          errors: [],
+        },
+      ],
+      20_000,
+      {
+        summary: {
+          newRegressions: 1,
+          knownRegressions: 2,
+          fixedKnownRegressions: 3,
+          catalogStale: 4,
+          catalogSyncUnavailable: false,
+          usedStaleCache: true,
+        },
+      }
+    );
+
+    const output = capture.read();
+    expect(output).toContain("┌");
+    expect(output).toContain("│ Result");
+    expect(output).toContain("FAILED");
+    expect(output).toContain("│ Passed");
+    expect(output).toContain("│ Failed");
+    expect(output).toContain("│ Skipped");
+    expect(output).toContain("│ Not run");
+    expect(output).toContain("│ Files");
+    expect(output).toContain("│ Duration");
+    expect(output).toContain("│ New regressions");
+    expect(output).toContain("│ Known regressions");
+    expect(output).toContain("│ Fixed known");
+    expect(output).toContain("│ Catalog stale");
+    expect(output).toContain("│ Catalog sync");
+    expect(output).not.toContain("Failures:");
+    expect(output).not.toContain("Runtime Errors:");
   });
 });

package/lib/cli/presentation/summary-box.mjs

@@ -0,0 +1,45 @@
+import figures from "figures";
+import { clamp, getTerminalWidth, measureWidth, padEndVisible, wrapText } from "./terminal-layout.mjs";
+
+export function renderSummaryBox(
+  rows,
+  {
+    stdout = process.stdout,
+    widthRatio = 0.55,
+    minWidth = 30,
+    maxWidth = 56,
+    minValueWidth = 8,
+    maxKeyWidth = 12,
+  } = {}
+) {
+  if (!Array.isArray(rows) || rows.length === 0) return [];
+
+  const terminalWidth = getTerminalWidth(stdout, 100);
+  const preferredWidth = clamp(Math.floor(terminalWidth * widthRatio), minWidth, maxWidth);
+  const maxRenderableWidth = Math.max(minWidth, Math.min(preferredWidth, terminalWidth - 1));
+  const keyWidth = Math.min(
+    maxKeyWidth,
+    Math.max(...rows.map(([label]) => measureWidth(label)), 6)
+  );
+  const minBoxWidth = keyWidth + minValueWidth + 7;
+  const boxWidth = Math.max(minBoxWidth, maxRenderableWidth);
+  const valueWidth = Math.max(minValueWidth, boxWidth - keyWidth - 7);
+
+  const top = `${figures.lineDownRight}${figures.line.repeat(boxWidth - 2)}${figures.lineDownLeft}`;
+  const bottom = `${figures.lineUpRight}${figures.line.repeat(boxWidth - 2)}${figures.lineUpLeft}`;
+  const rendered = [top];
+
+  for (const [label, value] of rows) {
+    const wrappedValueLines = wrapText(value, valueWidth);
+    for (let index = 0; index < wrappedValueLines.length; index += 1) {
+      const keyCell = index === 0 ? padEndVisible(label, keyWidth) : " ".repeat(keyWidth);
+      const valueCell = padEndVisible(wrappedValueLines[index], valueWidth);
+      rendered.push(
+        `${figures.lineVertical} ${keyCell} ${figures.lineVertical} ${valueCell} ${figures.lineVertical}`
+      );
+    }
+  }
+
+  rendered.push(bottom);
+  return rendered;
+}

package/lib/cli/presentation/summary-box.test.mjs

@@ -0,0 +1,43 @@
+import { Writable } from "stream";
+import { describe, expect, it } from "vitest";
+import { renderSummaryBox } from "./summary-box.mjs";
+
+function createStream(columns) {
+  const stream = new Writable({
+    write(_chunk, _encoding, callback) {
+      callback();
+    },
+  });
+  stream.columns = columns;
+  return stream;
+}
+
+describe("summary box", () => {
+  it("renders key/value rows inside a bounded box", () => {
+    const lines = renderSummaryBox(
+      [
+        ["Result", "FAILED"],
+        ["Passed", "203"],
+        ["Duration", "8m 56s"],
+      ],
+      { stdout: createStream(80) }
+    );
+
+    expect(lines[0]).toMatch(/^┌/);
+    expect(lines.at(-1)).toMatch(/^└/);
+    expect(lines.join("\n")).toContain("Result");
+    expect(lines.join("\n")).toContain("FAILED");
+  });
+
+  it("wraps long values instead of widening to content length", () => {
+    const lines = renderSummaryBox(
+      [["Catalog sync", "Used stale GitHub cache while catalog validation was unavailable"]],
+      { stdout: createStream(40) }
+    );
+
+    expect(lines.length).toBeGreaterThan(4);
+    expect(lines.join("\n")).toContain("Catalog sync");
+    expect(lines.join("\n")).toContain("stale");
+    expect(lines.join("\n")).toContain("cache");
+  });
+});

package/lib/cli/presentation/terminal-layout.mjs

@@ -0,0 +1,43 @@
+import stringWidth from "string-width";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+
+export function getTerminalWidth(stream = process.stdout, fallback = 100) {
+  const columns = Number(stream?.columns);
+  if (Number.isFinite(columns) && columns > 0) return columns;
+  return fallback;
+}
+
+export function measureWidth(text) {
+  return stringWidth(String(text ?? ""));
+}
+
+export function stripTerminalFormatting(text) {
+  return stripAnsi(String(text ?? ""));
+}
+
+export function padEndVisible(text, width) {
+  const normalized = String(text ?? "");
+  const padding = Math.max(0, width - measureWidth(normalized));
+  return `${normalized}${" ".repeat(padding)}`;
+}
+
+export function wrapText(text, width) {
+  const normalized = String(text ?? "");
+  if (width <= 0) return [normalized];
+  return wrapAnsi(normalized, width, {
+    hard: true,
+    trim: false,
+    wordWrap: true,
+  }).split("\n");
+}
+
+export function renderIndentedBlock(text, { width, indent = "    " } = {}) {
+  const visibleIndent = measureWidth(indent);
+  const contentWidth = Math.max(12, width - visibleIndent);
+  return wrapText(text, contentWidth).map((line) => `${indent}${line}`);
+}
+
+export function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}

package/lib/cli/presentation/terminal-layout.test.mjs

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { getTerminalWidth, renderIndentedBlock, wrapText } from "./terminal-layout.mjs";
+
+describe("terminal layout", () => {
+  it("falls back to a default width when stream columns are unavailable", () => {
+    expect(getTerminalWidth({}, 91)).toBe(91);
+  });
+
+  it("wraps indented blocks to the provided width", () => {
+    const lines = renderIndentedBlock("response: abcdefghijklmnopqrstuvwxyz", {
+      width: 20,
+      indent: "    ",
+    });
+
+    expect(lines[0].startsWith("    ")).toBe(true);
+    expect(lines.length).toBeGreaterThan(1);
+  });
+
+  it("hard-wraps long unbroken values", () => {
+    const lines = wrapText("abcdefghijklmnopqrstuvwxyz", 8);
+    expect(lines.length).toBeGreaterThan(1);
+  });
+});

package/lib/cli/viewer.mjs

@@ -109,11 +109,11 @@ export function formatFileDetail(productDir, runArtifact, subject, options = {})
     for (const line of codeFrame) lines.push(`  ${line}`);
   }
 
-  if (subject.file.triage) {
+  if (subject.file.diagnosis) {
     lines.push("");
-    lines.push("Triage:");
-    const triageLines = formatTriage(subject.file.triage);
-    for (const line of triageLines) lines.push(`  ${line}`);
+    lines.push("Diagnosis:");
+    const diagnosisLines = formatDiagnosis(subject.file.diagnosis);
+    for (const line of diagnosisLines) lines.push(`  ${line}`);
   }
 
   const setupOperations = getSetupOperationsForService(runArtifact, subject.service.name);
@@ -290,30 +290,29 @@ function formatResponseLine(detail) {
   return parts.join(" ");
 }
 
-function formatTriage(triage) {
-  const lines = [`status: ${triage.status}`];
-  if (triage.classifications?.length) {
-    lines.push(`classification: ${triage.classifications.join(", ")}`);
+function formatDiagnosis(diagnosis) {
+  const lines = [`status: ${diagnosis.status}`];
+  if (diagnosis.classifications?.length) {
+    lines.push(`classification: ${diagnosis.classifications.join(", ")}`);
   }
-  if (triage.availability?.mode) {
-    lines.push(
-      `validation: ${triage.availability.mode}${triage.availability.reason ? ` (${triage.availability.reason})` : ""}`
-    );
-  }
-  for (const entry of triage.entries || []) {
+  for (const entry of diagnosis.entries || []) {
     lines.push(`issue: ${entry.issue.repo}#${entry.issue.number}`);
-    if (entry.issue.url) lines.push(`url: ${entry.issue.url}`);
+    lines.push(`summary: ${entry.summary}`);
+    if (entry.github?.url) lines.push(`url: ${entry.github.url}`);
     if (entry.github?.state) {
       lines.push(`github state: ${entry.github.state}${entry.github.cached ? " (cache)" : ""}`);
     }
-    if (entry.validationStatus) lines.push(`validation status: ${entry.validationStatus}`);
-    if (entry.findings?.length) {
-      for (const finding of entry.findings.slice(0, 3)) {
-        lines.push(`finding: ${finding.message}`);
+    if (entry.syncStatus) lines.push(`catalog status: ${entry.syncStatus}`);
+    if (entry.catalogFindings?.length) {
+      for (const finding of entry.catalogFindings.slice(0, 3)) {
+        lines.push(`catalog finding: ${finding.message}`);
       }
     }
     break;
   }
+  if (diagnosis.status === "new_regression") {
+    lines.push("next: review .testkit/results/latest.json drafts.newRegressions for a prepared catalog entry");
+  }
   return lines;
 }
 

package/lib/config/index.mjs

@@ -14,9 +14,9 @@ import {
   detectNextApp,
   inferLocalRuntime,
   normalizeBrowserServiceConfig,
+  normalizeRegressionsConfig,
   normalizeOptionalString,
   normalizeRepoExecution,
-  normalizeReportingConfig,
   normalizeRuntimeConfig,
 } from "./runtime.mjs";
 import { normalizeServiceRequirements, normalizeSkipConfig } from "./skip-config.mjs";
@@ -30,7 +30,7 @@ export async function loadConfigContext(opts = {}) {
   const configContext = opts.configContext || (await loadTestkitConfig(productDir));
   const { config, configFile } = configContext;
   const execution = normalizeRepoExecution(config.execution);
-  const reporting = normalizeReportingConfig(config.reporting);
+  const regressions = normalizeRegressionsConfig(config.regressions);
   const toolchains = normalizeToolchainRegistry(config.toolchains);
   const discoveryConfig = normalizeRepoDiscoveryConfig(config.discovery);
   const explicitServices = config.services || {};
@@ -54,7 +54,7 @@ export async function loadConfigContext(opts = {}) {
         configFile,
         execution,
         discovery: discoveryConfig,
-        reporting,
+        regressions,
         toolchains,
         explicitService: explicitServices[name] || {},
         discoveredService: discovery.services[name] || null,
@@ -71,7 +71,7 @@ export async function loadConfigContext(opts = {}) {
     configFile,
     execution,
     discovery: discoveryConfig,
-    reporting,
+    regressions,
     toolchains,
     explicitServices,
     discovery,
@@ -102,7 +102,7 @@ function normalizeServiceConfig({
   configFile,
   execution,
   discovery,
-  reporting,
+  regressions,
   toolchains,
   explicitService,
   discoveredService,
@@ -156,7 +156,7 @@ function normalizeServiceConfig({
     suites,
     testkit: {
       execution,
-      reporting,
+      regressions,
       dependsOn: explicitService.dependsOn || [],
       discovery: normalizedDiscovery,
       database,

package/lib/config/runtime.mjs

@@ -15,23 +15,23 @@ import {
   parseModuleSpecifier,
 } from "../shared/configured-steps.mjs";
 import { buildConfigToPrepare, normalizeBuildConfig } from "../shared/build-config.mjs";
-import { normalizeKnownFailureIssueValidationConfig } from "../known-failures/github.mjs";
+import { normalizeRegressionSyncConfig } from "../regressions/github.mjs";
 import { normalizeRuntimeToolchain } from "../toolchains/index.mjs";
 import { resolveServiceCwd } from "./paths.mjs";
 
-export function normalizeReportingConfig(value) {
+export function normalizeRegressionsConfig(value) {
   if (!value) return null;
 
-  const knownFailuresFile = normalizeOptionalString(value.knownFailuresFile);
-  if (!knownFailuresFile) {
-    throw new Error('testkit.config.ts reporting.knownFailuresFile must be a non-empty string');
+  const file = normalizeOptionalString(value.file);
+  if (!file) {
+    throw new Error('testkit.config.ts regressions.file must be a non-empty string');
   }
 
-  const issueValidation = normalizeKnownFailureIssueValidationConfig(value.issueValidation);
+  const sync = normalizeRegressionSyncConfig(value.sync);
 
   return {
-    knownFailuresFile,
-    issueValidation,
+    file,
+    sync,
   };
 }
 

package/lib/config-api/index.d.ts

@@ -143,7 +143,7 @@ export interface BrowserServiceConfig {
   origins?: string[];
 }
 
-export interface KnownFailureIssueValidationConfig {
+export interface RegressionSyncConfig {
   provider?: "github";
   mode?: "off" | "warn" | "error";
   cacheTtlSeconds?: number;
@@ -412,9 +412,9 @@ export interface TestkitConfig {
   profiles?: {
     http?: Record<string, HttpSuiteConfig<any>>;
   };
-  reporting?: {
-    knownFailuresFile?: string;
-    issueValidation?: KnownFailureIssueValidationConfig;
+  regressions?: {
+    file?: string;
+    sync?: RegressionSyncConfig;
   };
   services?: Record<string, ServiceConfig>;
   toolchains?: Record<string, ToolchainConfig>;

package/lib/package.test.mjs

@@ -42,9 +42,9 @@ describe("package metadata", () => {
       types: "./lib/discovery/index.d.ts",
       default: "./lib/discovery/index.mjs",
     });
-    expect(packageJson.exports["./known-failures"]).toEqual({
-      types: "./lib/known-failures/index.d.ts",
-      default: "./lib/known-failures/index.mjs",
+    expect(packageJson.exports["./regressions"]).toEqual({
+      types: "./lib/regressions/index.d.ts",
+      default: "./lib/regressions/index.mjs",
     });
     expect(fs.existsSync(path.join(rootDir, "lib", "index.d.ts"))).toBe(true);
     expect(fs.existsSync(path.join(rootDir, "lib", "config-api", "index.d.ts"))).toBe(true);
@@ -54,6 +54,6 @@ describe("package metadata", () => {
     expect(fs.existsSync(path.join(rootDir, "lib", "runtime", "index.d.ts"))).toBe(true);
     expect(fs.existsSync(path.join(rootDir, "lib", "vitest", "index.d.ts"))).toBe(true);
     expect(fs.existsSync(path.join(rootDir, "lib", "discovery", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "known-failures", "index.d.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(rootDir, "lib", "regressions", "index.d.ts"))).toBe(true);
   });
 });