@elench/testkit 0.1.108 → 0.1.110

package/lib/domain/test-types.mjs

@@ -0,0 +1,44 @@
+export const TEST_TYPE_ORDER = ["ui", "e2e", "scenario", "int", "dal", "load"];
+export const TEST_TYPES = new Set(TEST_TYPE_ORDER);
+export const RUN_TYPE_ORDER = [...TEST_TYPE_ORDER, "all"];
+export const RUN_TYPES = new Set(RUN_TYPE_ORDER);
+export const LEGACY_TEST_TYPE_ALIASES = new Map([
+  ["pw", "ui"],
+]);
+
+const TEST_TYPE_LABELS = {
+  ui: "UI",
+  e2e: "E2E",
+  scenario: "Scenario",
+  int: "INT",
+  dal: "DAL",
+  load: "Load",
+};
+
+export function normalizePublicTestType(value) {
+  const normalized = String(value || "").trim();
+  return LEGACY_TEST_TYPE_ALIASES.get(normalized) || normalized;
+}
+
+export function isPublicTestType(value) {
+  return TEST_TYPES.has(normalizePublicTestType(value));
+}
+
+export function isRunType(value) {
+  const normalized = normalizePublicTestType(value);
+  return normalized === "all" || TEST_TYPES.has(normalized);
+}
+
+export function formatPublicTestType(value) {
+  const normalized = normalizePublicTestType(value);
+  return TEST_TYPE_LABELS[normalized] || String(value || "");
+}
+
+export function publicTestTypeList({ includeAll = false, includeLegacy = false } = {}) {
+  const values = includeAll ? RUN_TYPE_ORDER : TEST_TYPE_ORDER;
+  return includeLegacy ? [...values, "pw"] : [...values];
+}
+
+export function publicTestTypeListText(options = {}) {
+  return publicTestTypeList(options).join(", ");
+}

package/lib/history/index.d.ts

@@ -15,8 +15,7 @@ export interface TestHistoryEntry extends TestHistorySummary {
   path: string;
   service: string;
   suiteName: string;
-  selectionType: string;
-  framework: string;
+  type: string;
   notRunCount: number;
   durationCount: number;
 }
@@ -37,10 +36,10 @@ export declare function updateHistoryFromRunArtifact(
 ): TestHistoryDocument;
 export declare function summarizeHistoryForFiles(
   history: TestHistoryDocument,
-  files?: Array<{ id: string; service: string; selectionType: string; path: string }>
+  files?: Array<{ id: string; service: string; type: string; path: string }>
 ): Map<string, TestHistorySummary>;
 export declare function buildHistoryTestId(
   serviceName: string,
-  selectionType: string,
+  type: string,
   filePath: string
 ): string;

package/lib/history/index.mjs

@@ -52,8 +52,7 @@ export function updateHistoryFromRunArtifact(history, runArtifact, recordedAt =
               path: file.path,
               service: service.name,
               suiteName: suite.name,
-              selectionType: suite.type,
-              framework: normalizeArtifactFramework(suite.framework),
+              type: suite.type,
               firstSeenAt: seenAt,
               lastSeenAt: seenAt,
               lastRunAt: seenAt,
@@ -70,8 +69,7 @@ export function updateHistoryFromRunArtifact(history, runArtifact, recordedAt =
         next.path = file.path;
         next.service = service.name;
         next.suiteName = suite.name;
-        next.selectionType = suite.type;
-        next.framework = normalizeArtifactFramework(suite.framework);
+        next.type = suite.type;
         next.lastSeenAt = seenAt;
         next.lastRunAt = seenAt;
         next.runCount += 1;
@@ -106,7 +104,7 @@ export function summarizeHistoryForFiles(history, files = []) {
   const normalized = normalizeHistory(history);
   const byId = new Map();
   for (const file of files) {
-    const entry = normalized.tests[file.id] || normalized.tests[buildHistoryTestId(file.service, file.selectionType, file.path)];
+    const entry = normalized.tests[file.id] || normalized.tests[buildHistoryTestId(file.service, file.type, file.path)];
     if (!entry) continue;
     byId.set(file.id, {
       firstSeenAt: entry.firstSeenAt || null,
@@ -123,8 +121,8 @@ export function summarizeHistoryForFiles(history, files = []) {
   return byId;
 }
 
-export function buildHistoryTestId(serviceName, selectionType, filePath) {
-  return [serviceName, selectionType, normalizePath(filePath)].join("|");
+export function buildHistoryTestId(serviceName, type, filePath) {
+  return [serviceName, type, normalizePath(filePath)].join("|");
 }
 
 function normalizeHistory(parsed) {
@@ -135,8 +133,7 @@ function normalizeHistory(parsed) {
       path: normalizePath(entry.path || ""),
       service: String(entry.service || ""),
       suiteName: String(entry.suiteName || ""),
-      selectionType: String(entry.selectionType || ""),
-      framework: normalizeArtifactFramework(entry.framework || "k6"),
+      type: String(entry.type || entry.selectionType || ""),
       firstSeenAt: entry.firstSeenAt || null,
       lastSeenAt: entry.lastSeenAt || null,
       lastRunAt: entry.lastRunAt || null,
@@ -156,11 +153,6 @@ function normalizeHistory(parsed) {
   };
 }
 
-function normalizeArtifactFramework(value) {
-  if (value === "default") return "k6";
-  return value || "k6";
-}
-
 function normalizePath(filePath) {
   return String(filePath).split(path.sep).join("/").replace(/^\.\/+/, "");
 }

package/lib/runner/formatting.mjs

@@ -40,8 +40,7 @@ export function longestServiceName(results) {
 }
 
 export function formatFrameworkLabel(framework) {
-  if (!framework || framework === "k6") return "";
-  return framework;
+  return "";
 }
 
 export function formatSuiteFramework(framework) {
@@ -175,7 +174,7 @@ export function buildDebugRunSummaryLines(results, durationMs, regressionReport
       const fileDetail =
         suite.failedFiles.length > 0 ? `  (${suite.failedFiles.join(", ")})` : "";
       lines.push(
-        `  - ${suite.type}:${suite.name}${formatSuiteFramework(suite.framework)}${fileDetail} · ${formatDuration(suite.durationMs)}`
+        `  - ${suite.type}:${suite.name}${fileDetail} · ${formatDuration(suite.durationMs)}`
       );
       if (suite.error) {
         lines.push(`    ${suite.error}`);

package/lib/runner/maintenance.mjs

@@ -1,15 +1,14 @@
 import fs from "fs";
+import path from "path";
 import {
   cleanupOrphanedLocalInfrastructure,
-  collectServiceDatabaseStatus,
   destroyRuntimeDatabase,
   destroyServiceDatabaseCache,
   isDatabaseStateDir,
 } from "../database/index.mjs";
-import { cleanupRuns, formatRunSummary } from "./lifecycle.mjs";
-import { buildRunStatusLines } from "./readiness.mjs";
+import { cleanupRuns, formatRunSummary, isPidRunning, listRunManifests } from "./lifecycle.mjs";
 import { findGraphDirsForService, findRuntimeStateDirs } from "./state.mjs";
-import { collectStateDirLines } from "./state-io.mjs";
+import { collectCleanupTargets, collectStatusModel } from "./status-model.mjs";
 
 export async function destroy(config) {
   await cleanupRuns(config.productDir, { includeActive: true });
@@ -34,50 +33,152 @@ export async function destroy(config) {
   await cleanupOrphanedLocalInfrastructure(config.productDir);
 }
 
-export function showStatus(config) {
-  const lines = [...buildRunStatusLines(config.productDir)];
-  const graphDirs = findGraphDirsForService(config.productDir, config.name);
-  const hasDirectState = fs.existsSync(config.stateDir);
-  const hasGraphState = graphDirs.length > 0;
-
-  if (!hasDirectState && !hasGraphState) {
-    lines.push("No state — run tests first.");
-  } else {
-    if (hasDirectState) {
-      lines.push("  service-state/");
-      lines.push(...collectStateDirLines(config.stateDir, "    "));
+export function showStatus(config, options = {}) {
+  return collectStatusModel(config, options);
+}
+
+export async function cleanup(productDir, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const allConfigs = options.allConfigs || [];
+  const serviceName = options.serviceName || null;
+  const cache = normalizeCacheSelection(options.cache);
+  const summary = dryRun
+    ? collectRunCleanupPreview(productDir)
+    : await cleanupRuns(productDir, { includeActive: false });
+  const targets = collectCleanupTargets(productDir, {
+    allConfigs,
+    serviceName,
+    cache,
+  });
+
+  const runtimeCleaned = [];
+  const bundleCleaned = [];
+  const assistantCleaned = [];
+
+  if (!dryRun) {
+    for (const target of targets.runtime) {
+      await cleanupRuntimeDir(productDir, target.path);
+      runtimeCleaned.push(target);
+    }
+    for (const target of targets.bundles) {
+      fs.rmSync(target.path, { force: true });
+      bundleCleaned.push(target);
     }
-    for (const graphDir of graphDirs) {
-      lines.push(`  graph-state/${graphDir.split("/").at(-1)}/`);
-      lines.push(...collectStateDirLines(graphDir, "    "));
+    for (const target of targets.assistant) {
+      fs.rmSync(target.path, { force: true });
+      assistantCleaned.push(target);
     }
+    pruneKnownEmptyDirs(productDir);
   }
 
-  lines.push(...collectServiceDatabaseStatus(config.productDir, config.name));
-  return {
-    name: config.name,
-    lines,
-  };
-}
+  const lines = [];
+  for (const manifest of summary.cleaned) {
+    lines.push(`${dryRun ? "Would clean" : "Cleaned"} stale run ${formatRunSummary(manifest)}`);
+  }
+  for (const manifest of summary.skippedActive) {
+    lines.push(`Active run still present: ${formatRunSummary(manifest)}`);
+  }
+  for (const target of targets.runtime) {
+    lines.push(`${dryRun ? "Would remove" : "Removed"} stale runtime ${target.graph}/${target.runtimeId}`);
+  }
+  appendBoundedFileCleanupLines(lines, {
+    productDir,
+    targets: targets.bundles,
+    label: "bundle cache file",
+    dryRun,
+  });
+  appendBoundedFileCleanupLines(lines, {
+    productDir,
+    targets: targets.assistant,
+    label: "assistant command result",
+    dryRun,
+  });
 
-export async function cleanup(productDir) {
-  const summary = await cleanupRuns(productDir, { includeActive: false });
-  if (summary.cleaned.length === 0 && summary.skippedActive.length === 0) {
+  if (lines.length === 0) {
     return {
       ...summary,
+      dryRun,
+      targets,
+      runtimeCleaned,
+      bundleCleaned,
+      assistantCleaned,
       lines: ["No stale runs to clean."],
     };
   }
 
-  const lines = [];
-  for (const manifest of summary.cleaned) {
-    lines.push(`Cleaned stale run ${formatRunSummary(manifest)}`);
-  }
-  for (const manifest of summary.skippedActive) {
-    lines.push(`Active run still present: ${formatRunSummary(manifest)}`);
-  }
   return {
     ...summary,
+    dryRun,
+    targets,
+    runtimeCleaned,
+    bundleCleaned,
+    assistantCleaned,
     lines,
   };
 }
+
+async function cleanupRuntimeDir(productDir, runtimeDir) {
+  if (!runtimeDir || !fs.existsSync(runtimeDir)) return;
+  const runtimeStateDirs = findRuntimeStateDirs(runtimeDir, isDatabaseStateDir);
+  for (const stateDir of runtimeStateDirs) {
+    await destroyRuntimeDatabase({ productDir, stateDir });
+  }
+  fs.rmSync(runtimeDir, { recursive: true, force: true });
+}
+
+function normalizeCacheSelection(cache) {
+  const values = Array.isArray(cache) ? cache.filter(Boolean).map(String) : [cache].filter(Boolean).map(String);
+  if (values.includes("all")) return ["runtime", "bundles", "assistant"];
+  return values;
+}
+
+function pruneKnownEmptyDirs(productDir) {
+  for (const dir of [
+    path.join(productDir, ".testkit", "assistant", "command-results"),
+    path.join(productDir, ".testkit", "assistant"),
+    path.join(productDir, ".testkit", "_bundles"),
+    path.join(productDir, ".testkit", "_graphs"),
+  ]) {
+    pruneEmptyDir(dir);
+  }
+}
+
+function pruneEmptyDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  try {
+    if (fs.readdirSync(dir).length === 0) fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+function relativeToProduct(productDir, filePath) {
+  return path.relative(productDir, filePath).split(path.sep).join("/");
+}
+
+function appendBoundedFileCleanupLines(lines, { productDir, targets, label, dryRun }) {
+  if (!targets || targets.length === 0) return;
+  const verb = dryRun ? "Would remove" : "Removed";
+  lines.push(`${verb} ${targets.length} ${label}${targets.length === 1 ? "" : "s"}.`);
+  for (const target of targets.slice(0, 10)) {
+    lines.push(`  ${relativeToProduct(productDir, target.path)}`);
+  }
+  if (targets.length > 10) {
+    lines.push(`  ... ${targets.length - 10} more ${label}${targets.length - 10 === 1 ? "" : "s"}`);
+  }
+}
+
+function collectRunCleanupPreview(productDir) {
+  const summary = {
+    cleaned: [],
+    skippedActive: [],
+  };
+  for (const manifest of listRunManifests(productDir)) {
+    if (isPidRunning(manifest.pid)) {
+      summary.skippedActive.push(manifest);
+    } else {
+      summary.cleaned.push(manifest);
+    }
+  }
+  return summary;
+}

package/lib/runner/planning.mjs

@@ -4,7 +4,7 @@ import {
   suiteSelectionType,
 } from "./suite-selection.mjs";
 
-const TYPE_ORDER = ["dal", "integration", "e2e", "scenario", "load"];
+const TYPE_ORDER = ["ui", "e2e", "scenario", "integration", "dal", "load"];
 
 export function taskNeedsLocalRuntime(task) {
   return task.type !== "dal";

package/lib/runner/results.mjs

@@ -263,7 +263,6 @@ function finalizeSuite(suite) {
   return {
     name: suite.name,
     type: suite.displayType,
-    framework: formatFrameworkForArtifact(suite.framework),
     failed: suite.failedFiles.length > 0,
     fileCount: suite.fileCount,
     completedFileCount: suite.completedFileCount,
@@ -285,11 +284,6 @@ function normalizePathSeparators(filePath) {
   return filePath.split(path.sep).join("/");
 }
 
-function formatFrameworkForArtifact(framework) {
-  if (framework === "k6") return "default";
-  return framework;
-}
-
 function normalizeOutcomeStatus(outcome) {
   if (outcome?.status === "not_run") return "not_run";
   if (outcome?.status === "skipped") return "skipped";