@elench/testkit 0.1.52 → 0.1.54

package/lib/cli/index.mjs

@@ -1,119 +1,9 @@
-import { cac } from "cac";
-import { loadConfigs } from "../config/index.mjs";
-import {
-  runKnownFailuresRenderCommand,
-  runKnownFailuresValidateCommand,
-} from "./known-failures.mjs";
-import { runDatabaseSnapshotCaptureCommand } from "./db.mjs";
-import {
-  parseFileTimeoutOption,
-  parseShardOption,
-  parseSuiteOption,
-  parseTypeOption,
-  parseWorkersOption,
-  resolveRequestedFiles,
-  resolveCliSelection,
-} from "./args.mjs";
-import * as runner from "../runner/index.mjs";
+import { execute } from "@oclif/core";
+import { normalizeCliArgs } from "./entrypoint.mjs";
 
 export async function run(argv = process.argv) {
-  const cli = cac("testkit");
-
-  cli
-    .command("[first] [second] [third]", "Run test suites")
-    .option("--service <name>", "Run only one service")
-    .option("-t, --type <name>", "Run specific suite type(s): int, e2e, dal, load, pw, all", {
-      default: [],
-    })
-    .option("-s, --suite <name>", "Run specific suite(s)", { default: [] })
-    .option("-f, --file <path>", "Run specific file(s)", { default: [] })
-    .option("--dir <path>", "Explicit product directory")
-    .option("--workers <n>", "Number of test executors for the whole run")
-    .option("--file-timeout-seconds <n>", "Per-file wall-clock timeout in seconds")
-    .option("--shard <i/n>", "Run only shard i of n at suite granularity")
-    .option("--write-status", "Write a deterministic testkit.status.json snapshot")
-    .option("--allow-partial-status", "Allow --write-status for filtered runs")
-    .option("--input <path>", "Known failures JSON path (repo-relative)")
-    .option("--output <path>", "Output path for render/snapshot commands")
-    .option("--status <path>", "Status artifact path for validation commands")
-    .option("--issue-mode <mode>", "Issue validation mode override: off, warn, error")
-    .option(
-      "--ignore-skip-rules",
-      "Run files even if testkit.setup.ts marks them skipped"
-    )
-    .action(async (first, second, third, options) => {
-      const { lifecycle, positionalType, knownFailuresAction, dbAction } = resolveCliSelection({
-        first,
-        second,
-        third,
-      });
-      if (knownFailuresAction === "render") {
-        await runKnownFailuresRenderCommand(options);
-        return;
-      }
-      if (knownFailuresAction === "validate") {
-        await runKnownFailuresValidateCommand(options);
-        return;
-      }
-      if (dbAction === "snapshot-capture") {
-        await runDatabaseSnapshotCaptureCommand(options);
-        return;
-      }
-
-      const allConfigs = await loadConfigs({ dir: options.dir });
-      const configs = options.service
-        ? allConfigs.filter((config) => config.name === options.service)
-        : allConfigs;
-      if (options.service && configs.length === 0) {
-        const available = allConfigs.map((config) => config.name).join(", ");
-        throw new Error(`Service "${options.service}" not found. Available: ${available}`);
-      }
-
-      // Lifecycle commands
-      if (lifecycle === "cleanup") {
-        await runner.cleanup(allConfigs[0]?.productDir || process.cwd());
-        return;
-      }
-
-      if (lifecycle === "status" || lifecycle === "destroy") {
-        for (const config of configs) {
-          if (configs.length > 1) console.log(`\n── ${config.name} ──`);
-          if (lifecycle === "status") runner.showStatus(config);
-          else await runner.destroy(config);
-        }
-        return;
-      }
-
-      const workers = options.workers == null ? null : parseWorkersOption(options.workers);
-      const fileTimeoutSeconds =
-        options.fileTimeoutSeconds == null
-          ? null
-          : parseFileTimeoutOption(options.fileTimeoutSeconds);
-      const shard = parseShardOption(options.shard);
-      const typeValues = parseTypeOption(options.type, positionalType);
-      const suiteSelectors = parseSuiteOption(options.suite);
-      const rawFileNames = Array.isArray(options.file) ? options.file : [options.file].filter(Boolean);
-      const productDir = allConfigs[0]?.productDir || process.cwd();
-      const fileNames = resolveRequestedFiles(rawFileNames, productDir, process.cwd());
-      await runner.runAll(
-        configs,
-        typeValues,
-        suiteSelectors,
-        {
-          ...options,
-          typeValues,
-          fileNames,
-          workers,
-          fileTimeoutSeconds,
-          shard,
-          serviceFilter: options.service || null,
-        },
-        allConfigs
-      );
-    });
-
-  cli.help();
-  const parsed = cli.parse(argv, { run: false });
-  await cli.runMatchedCommand();
-  return parsed;
+  return execute({
+    args: normalizeCliArgs(argv.slice(2)),
+    dir: import.meta.url,
+  });
 }

package/lib/cli/presentation/code-frames.mjs

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+import { codeFrameColumns } from "@babel/code-frame";
+import { createColors } from "picocolors";
+
+const pc = createColors(Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR));
+
+export function findFailureLocation(detail = {}, fallbackError = "") {
+  if (detail?.location?.path && Number.isFinite(detail?.location?.line)) {
+    return detail.location;
+  }
+
+  const stack = detail?.stack || fallbackError;
+  if (!stack) return null;
+  const match = String(stack).match(/(\/[^\s:()]+):(\d+):(\d+)/);
+  if (!match) return null;
+  return {
+    path: match[1],
+    line: Number(match[2]),
+    column: Number(match[3]),
+  };
+}
+
+export function renderCodeFrame(location, options = {}) {
+  if (!location?.path || !Number.isFinite(location.line)) return [];
+  if (!fs.existsSync(location.path)) return [];
+
+  try {
+    const source = fs.readFileSync(location.path, "utf8");
+    const frame = codeFrameColumns(
+      source,
+      {
+        start: {
+          line: location.line,
+          column: Math.max(1, Number(location.column) || 1),
+        },
+      },
+      {
+        highlightCode: Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR),
+        linesAbove: options.linesAbove ?? 2,
+        linesBelow: options.linesBelow ?? 2,
+      }
+    );
+    const label = `${options.label || "code"}: ${formatLocation(location, options.cwd)}`;
+    return [pc.bold(label), ...frame.split(/\r?\n/)];
+  } catch {
+    return [];
+  }
+}
+
+export function formatLocation(location, cwd = process.cwd()) {
+  if (!location?.path || !Number.isFinite(location.line)) return null;
+  const relativePath = path.isAbsolute(location.path)
+    ? path.relative(cwd, location.path) || path.basename(location.path)
+    : location.path;
+  return `${relativePath}:${location.line}:${location.column || 1}`;
+}

package/lib/cli/presentation/code-frames.test.mjs

@@ -0,0 +1,71 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { findFailureLocation, formatLocation, renderCodeFrame } from "./code-frames.mjs";
+
+const cleanups = [];
+
+afterEach(() => {
+  while (cleanups.length > 0) {
+    cleanups.pop()();
+  }
+});
+
+describe("code frame presentation", () => {
+  it("finds a location from structured failure metadata", () => {
+    expect(
+      findFailureLocation({
+        location: {
+          path: "/tmp/example.ts",
+          line: 10,
+          column: 2,
+        },
+      })
+    ).toEqual({
+      path: "/tmp/example.ts",
+      line: 10,
+      column: 2,
+    });
+  });
+
+  it("renders a code frame for a local file", () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-code-frame-"));
+    cleanups.push(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+    const filePath = path.join(tempDir, "example.ts");
+    fs.writeFileSync(
+      filePath,
+      [
+        "export function run() {",
+        "  const value = 1;",
+        "  return value + missing;",
+        "}",
+      ].join("\n")
+    );
+
+    const lines = renderCodeFrame(
+      {
+        path: filePath,
+        line: 3,
+        column: 18,
+      },
+      { cwd: tempDir }
+    );
+
+    expect(lines.join("\n")).toContain("example.ts:3:18");
+    expect(lines.join("\n")).toContain("return value + missing;");
+  });
+
+  it("formats locations relative to the cwd", () => {
+    expect(
+      formatLocation(
+        {
+          path: "/tmp/example.ts",
+          line: 7,
+          column: 3,
+        },
+        "/tmp"
+      )
+    ).toBe("example.ts:7:3");
+  });
+});

package/lib/cli/presentation/colors.mjs

@@ -0,0 +1,29 @@
+import { createColors } from "picocolors";
+
+const pc = createColors(Boolean(process.stdout?.isTTY || process.env.FORCE_COLOR));
+
+export function colorStatus(status) {
+  if (status === "PASS") return pc.green(status);
+  if (status === "FAIL") return pc.red(status);
+  if (status === "SKIP") return pc.yellow(status);
+  if (status === "RUN") return pc.cyan(status);
+  return status;
+}
+
+export function dim(text) {
+  return pc.dim(text);
+}
+
+export function colorResultLine(line) {
+  if (/^Result: PASSED\b/.test(line)) return line.replace("PASSED", pc.green("PASSED"));
+  if (/^Result: FAILED\b/.test(line)) return line.replace("FAILED", pc.red("FAILED"));
+  return line;
+}
+
+export function colorSectionLine(line) {
+  if (line === "Failures:" || line === "Runtime Errors:" || line === "Known-failure issues:" || line === "Triage:") {
+    return pc.bold(line);
+  }
+  if (/^Summary: /.test(line)) return line.replace("Summary:", `${pc.bold("Summary:")}`);
+  return colorResultLine(line);
+}

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

@@ -0,0 +1,100 @@
+import path from "path";
+import {
+  buildCompactRunSummaryLines,
+  buildDebugRunSummaryLines,
+  formatDuration,
+} from "../../runner/formatting.mjs";
+import { colorSectionLine, colorStatus, dim } from "./colors.mjs";
+
+export function createRunReporter({ outputMode = "compact", stdout = process.stdout, stderr = process.stderr } = {}) {
+  const mode = outputMode || "compact";
+  return {
+    outputMode: mode,
+    writeLine(line = "") {
+      stdout.write(`${line}\n`);
+    },
+    writeDebugLine(line = "") {
+      stdout.write(`${line}\n`);
+    },
+    phaseStarted(label) {
+      if (mode !== "debug") return;
+      stdout.write(`\n── ${label} ──\n`);
+    },
+    toolchainResolved(config, resolvedToolchain) {
+      if (mode !== "debug") return;
+      stdout.write(
+        `[testkit] ${config.runtimeLabel || config.name}:${config.name} toolchain ${resolvedToolchain.summary}\n`
+      );
+    },
+    localServiceStarting(config, command) {
+      if (mode !== "debug") return;
+      stdout.write(`Starting ${config.runtimeLabel}:${config.name}: ${command}\n`);
+    },
+    serviceSkipped(config, reason) {
+      stdout.write(`${colorStatus("SKIP")} ${config.name} ${reason}\n`);
+    },
+    plannedSkip(entry) {
+      stdout.write(
+        `${colorStatus("SKIP")} ${entry.serviceName} ${entry.type} ${normalizePath(entry.file)} ${dim("0s")} ${shortenMessage(entry.reason || "skipped")}\n`
+      );
+    },
+    taskStarted(task, targetConfig) {
+      if (mode !== "debug") return;
+      stdout.write(`${colorStatus("RUN").padEnd(12)} ${targetConfig.name} ${task.type} ${task.file}\n`);
+    },
+    taskFinished(task, outcome) {
+      if (mode === "json") return;
+      const status = outcome.status === "skipped" ? "SKIP" : outcome.failed ? "FAIL" : "PASS";
+      const duration = formatDuration(outcome.durationMs || 0);
+      const primaryFailure = firstFailureDetail(outcome);
+      const preferredFailure =
+        primaryFailure && isThresholdWrapperMessage(outcome.error) ? primaryFailure : outcome.error || primaryFailure;
+      const detail =
+        status === "FAIL"
+          ? ` ${shortenMessage(preferredFailure || "failed")}`
+          : outcome.status === "not_run"
+            ? ` ${shortenMessage(outcome.reason || "not run")}`
+            : "";
+      stdout.write(
+        `${colorStatus(status)} ${task.serviceName} ${displayTaskType(task)} ${normalizePath(task.file)} ${dim(duration)}${detail}\n`
+      );
+    },
+    telemetry(message) {
+      if (mode === "json") return;
+      stdout.write(`${message}\n`);
+    },
+    runSummary(results, durationMs, knownFailureIssueValidation = null) {
+      const lines =
+        mode === "debug"
+          ? buildDebugRunSummaryLines(results, durationMs, knownFailureIssueValidation)
+          : buildCompactRunSummaryLines(results, durationMs, knownFailureIssueValidation);
+      for (const line of lines) stdout.write(`${colorSectionLine(line)}\n`);
+    },
+    error(message) {
+      stderr.write(`${message}\n`);
+    },
+  };
+}
+
+function displayTaskType(task) {
+  if (task.framework === "playwright") return "pw";
+  if (task.type === "integration") return "int";
+  return task.type;
+}
+
+function shortenMessage(message) {
+  return String(message).replace(/\s+/g, " ").trim().slice(0, 180);
+}
+
+function firstFailureDetail(outcome) {
+  const detail = outcome.failureDetails?.[0];
+  return detail?.message || detail?.title || null;
+}
+
+function isThresholdWrapperMessage(message) {
+  return /Default runtime thresholds failed:/.test(String(message || ""));
+}
+
+function normalizePath(filePath) {
+  return String(filePath).split(path.sep).join("/");
+}

package/lib/cli/tui/watch-app.mjs

@@ -0,0 +1,104 @@
+import React, { createElement, useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { formatDuration } from "../../runner/formatting.mjs";
+import { formatFileDetail, loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
+
+export function WatchApp({ productDir, serviceFilter = null }) {
+  const { exit } = useApp();
+  const [artifact, setArtifact] = useState(() => safeLoadArtifact(productDir));
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  const files = useMemo(() => collectFiles(artifact, serviceFilter), [artifact, serviceFilter]);
+  const selected = files[Math.min(selectedIndex, Math.max(0, files.length - 1))] || null;
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setArtifact(safeLoadArtifact(productDir));
+    }, 1_000);
+    return () => clearInterval(timer);
+  }, [productDir]);
+
+  useInput((input, key) => {
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (input === "r") {
+      setArtifact(safeLoadArtifact(productDir));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => Math.min(current + 1, Math.max(0, files.length - 1)));
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => Math.max(0, current - 1));
+    }
+  });
+
+  if (!artifact) {
+    return createElement(Text, null, `No run artifact found in ${productDir}`);
+  }
+
+  return createElement(
+    Box,
+    { flexDirection: "column" },
+    createElement(
+      Text,
+      null,
+      `testkit watch · q quit · r reload · ${artifact.run.status} · ${formatDuration(artifact.run.durationMs)}`
+    ),
+    createElement(
+      Box,
+      { marginTop: 1 },
+      createElement(
+        Box,
+        { width: "40%", flexDirection: "column", marginRight: 2 },
+        createElement(Text, null, "Files"),
+        ...files.map((entry, index) => {
+          const prefix = index === selectedIndex ? ">" : " ";
+          return createElement(
+            Text,
+            { key: `${entry.service.name}:${entry.file.path}` },
+            `${prefix} ${entry.file.status.toUpperCase().padEnd(7)} ${entry.file.path}`
+          );
+        })
+      ),
+      createElement(
+        Box,
+        { width: "60%", flexDirection: "column" },
+        createElement(Text, null, "Details"),
+        ...(selected
+          ? formatFileDetail(productDir, artifact, selected, { logTail: 8 })
+              .slice(0, 28)
+              .map((line, index) => createElement(Text, { key: `${index}:${line}` }, line))
+          : [createElement(Text, { key: "empty" }, "No file results")])
+      )
+    )
+  );
+}
+
+function safeLoadArtifact(productDir) {
+  try {
+    return loadLatestRunArtifact(productDir);
+  } catch {
+    return null;
+  }
+}
+
+function collectFiles(runArtifact, serviceFilter) {
+  if (!runArtifact) return [];
+  const entries = [];
+  for (const service of runArtifact.services || []) {
+    if (serviceFilter && service.name !== serviceFilter) continue;
+    for (const suite of service.suites || []) {
+      for (const file of suite.files || []) {
+        entries.push({ service, suite, file });
+      }
+    }
+  }
+  const failed = entries.filter((entry) => entry.file.status === "failed");
+  return (failed.length > 0 ? failed : entries).sort((left, right) =>
+    left.file.path.localeCompare(right.file.path)
+  );
+}