@elench/testkit 0.1.149 → 0.1.151

package/lib/regressions/github.mjs

@@ -1,4 +1,4 @@
-import { findMatchingRegressionEntries } from "./index.mjs";
+import { findMatchingRegressionCases } from "./index.mjs";
 import {
   applyStaleCacheFallback,
   loadIssueCache,
@@ -40,11 +40,13 @@ export function normalizeRegressionSyncConfig(value) {
     value.cacheTtlSeconds == null
       ? DEFAULT_CACHE_TTL_SECONDS
       : normalizePositiveInteger(value.cacheTtlSeconds, "testkit.config.ts regressions.sync.cacheTtlSeconds");
+  const apiBaseUrl = normalizeOptionalString(value.apiBaseUrl);
 
   return {
     provider,
     mode,
     cacheTtlSeconds,
+    apiBaseUrl,
   };
 }
 
@@ -62,7 +64,8 @@ export async function validateRegressionIssues({
   if (!document || !normalizedConfig || normalizedConfig.mode === "off") return null;
 
   const checks = collectObservedRegressionEntries(document, runArtifact, statusArtifact);
-  const issueNumbersByRepo = groupIssueNumbersByRepo(document.entries);
+  const cases = document.cases || [];
+  const issueNumbersByRepo = groupIssueNumbersByRepo(cases);
   const repoSlug = gitMetadata?.repoSlug || null;
   const remoteUrl = gitMetadata?.remoteUrl || null;
   const cache = loadIssueCache(productDir, CACHE_PATH, CACHE_SCHEMA_VERSION);
@@ -71,7 +74,9 @@ export async function validateRegressionIssues({
   let issuesByRepo = cacheResolution.issuesByRepo;
 
   if (cacheResolution.missingByRepo.size > 0) {
-    const client = transport || (await createDefaultGitHubIssueTransport());
+    const client = transport || (await createDefaultGitHubIssueTransport(process.env, {
+      apiBaseUrl: normalizedConfig.apiBaseUrl,
+    }));
     if (client) {
       try {
         const fetchedIssues = await fetchIssuesByRepo(client, cacheResolution.missingByRepo);
@@ -105,9 +110,11 @@ export async function validateRegressionIssues({
     }
   }
 
-  const entries = document.entries.map((entry) => {
+  const caseResults = cases.map((entry) => {
     const observed = checks.get(entry.id) || createObservedCheck(entry);
-    const issueData = issuesByRepo.get(entry.issue.repo)?.get(entry.issue.number) || null;
+    const issueData = entry.issue
+      ? issuesByRepo.get(entry.issue.repo)?.get(entry.issue.number) || null
+      : null;
     return buildIssueValidationEntry({ entry, observed, issueData });
   });
 
@@ -117,12 +124,12 @@ export async function validateRegressionIssues({
       code: "detected_repo_mismatch",
       severity: normalizedConfig.mode === "error" ? "error" : "warning",
       message:
-        `Regression catalog issueRepo ${document.issueRepo} does not match detected repo ${repoSlug}` +
+        `Regression case store issueRepo ${document.issueRepo} does not match detected repo ${repoSlug}` +
         (remoteUrl ? ` (${remoteUrl})` : ""),
     });
   }
 
-  const summary = buildIssueValidationSummary(entries, globalFindings);
+  const summary = buildIssueValidationSummary(caseResults, globalFindings);
   return {
     schemaVersion: 2,
     provider: "github",
@@ -139,7 +146,7 @@ export async function validateRegressionIssues({
     },
     findings: globalFindings,
     summary,
-    entries,
+    cases: caseResults,
   };
 }
 
@@ -182,17 +189,18 @@ export function buildRegressionSyncSummaryLines(result) {
   if (parts.length === 0) return [];
   return [
     "",
-    "Catalog issues:",
+    "Case store issues:",
     ...parts.map((part) => `  - ${part}`),
   ];
 }
 
 function collectObservedRegressionEntries(document, runArtifact, statusArtifact) {
   const observedTests = collectObservedTests(runArtifact, statusArtifact);
-  const checks = new Map(document.entries.map((entry) => [entry.id, createObservedCheck(entry)]));
+  const cases = document.cases || [];
+  const checks = new Map(cases.map((entry) => [entry.id, createObservedCheck(entry)]));
 
   for (const test of observedTests) {
-    const matchedEntries = findMatchingRegressionEntries(document, test);
+    const matchedEntries = findMatchingRegressionCases(document, test);
     for (const entry of matchedEntries) {
       const observed = checks.get(entry.id) || createObservedCheck(entry);
       observed.matchedTests += 1;
@@ -252,6 +260,7 @@ function createObservedCheck(entry) {
 function groupIssueNumbersByRepo(entries) {
   const map = new Map();
   for (const entry of entries) {
+    if (!entry.issue) continue;
     if (!map.has(entry.issue.repo)) {
       map.set(entry.issue.repo, []);
     }
@@ -271,11 +280,38 @@ function buildIssueValidationEntry({ entry, observed, issueData }) {
   const findings = [];
   const normalizedIssueState = normalizeIssueState(issueData?.state);
 
+  if (!entry.issue) {
+    return {
+      id: entry.id,
+      summary: entry.summary,
+      issue: null,
+      observed: {
+        matchedTests: observed.matchedTests,
+        executedTests: observed.executedTests,
+        passedTests: observed.passedTests,
+        failedTests: observed.failedTests,
+        skippedTests: observed.skippedTests,
+        notRunTests: observed.notRunTests,
+        reproduced: observed.failedTests > 0,
+      },
+      github: {
+        exists: null,
+        title: null,
+        state: null,
+        url: null,
+        checkedAt: null,
+        cached: false,
+      },
+      findings,
+      status: observed.matchedTests > 0 ? "unlinked" : "not_observed",
+    };
+  }
+
   if (issueData && issueData.exists === false) {
     findings.push({
       code: "issue_missing",
       severity: "error",
-      message: `Regression catalog entry ${entry.id} references missing issue #${entry.issue.number} in ${entry.issue.repo}`,
+      message: `Regression case ${entry.id} references missing issue #${entry.issue.number} in ${entry.issue.repo}`,
     });
   }
 
@@ -369,7 +405,7 @@ function resolveIssueValidationStatus(issueData, observed) {
   return "not_observed";
 }
 
-function buildIssueValidationSummary(entries, globalFindings) {
+function buildIssueValidationSummary(caseResults, globalFindings) {
   const byCode = {};
   const byStatus = {};
   let errors = 0;
@@ -381,7 +417,7 @@ function buildIssueValidationSummary(entries, globalFindings) {
     if (finding.severity === "warning") warnings += 1;
   }
 
-  for (const entry of entries) {
+  for (const entry of caseResults) {
     byStatus[entry.status] = (byStatus[entry.status] || 0) + 1;
     for (const finding of entry.findings) {
       byCode[finding.code] = (byCode[finding.code] || 0) + 1;
@@ -391,8 +427,8 @@ function buildIssueValidationSummary(entries, globalFindings) {
   }
 
   return {
-    entries: entries.length,
-    observedEntries: entries.filter((entry) => entry.observed.matchedTests > 0).length,
+    cases: caseResults.length,
+    observedCases: caseResults.filter((entry) => entry.observed.matchedTests > 0).length,
     errors,
     warnings,
     byCode,

package/lib/regressions/index.d.ts

@@ -1,10 +1,20 @@
 export type RegressionClassification =
   | "expected_failure"
+  | "flaky"
+  | "harness_bug"
   | "infra"
   | "product_bug"
   | "stale_test"
   | "test_bug";
 
+export type RegressionCaseState =
+  | "active"
+  | "coverage_missing"
+  | "fixed_pending_verification"
+  | "fix_claimed"
+  | "resolved"
+  | "untriaged";
+
 export interface RegressionIssueRef {
   repo: string;
   number: number;
@@ -13,32 +23,37 @@ export interface RegressionIssueRef {
 export interface RegressionFingerprint {
   service?: string;
   type?: string;
-  path: string;
+  path?: string;
+  pathGlob?: string;
   failureKey?: string;
   errorIncludes?: string;
 }
 
-export interface RegressionCatalogEntry {
+export interface RegressionCase {
   id: string;
+  state: RegressionCaseState;
   classification: RegressionClassification;
-  issue: RegressionIssueRef;
+  owner?: string;
+  issue: RegressionIssueRef | null;
   summary: string;
   cause: string;
   lastReviewedAt: string;
   fingerprints: RegressionFingerprint[];
+  lifecycle: Record<string, unknown>;
+  coverage: Record<string, unknown>;
 }
 
-export interface RegressionCatalogDocument {
-  schemaVersion: 1;
+export interface RegressionCaseStoreDocument {
+  schemaVersion: 2;
   issueRepo?: string | null;
-  entries: RegressionCatalogEntry[];
+  cases: RegressionCase[];
 }
 
-export interface RegressionCatalogValidationResult {
+export interface RegressionCaseStoreValidationResult {
   errors: string[];
   warnings: string[];
   stats: {
-    entries: number;
+    cases: number;
     fingerprints: number;
     failedTests: number;
     diagnosedFailedTests: number;
@@ -50,6 +65,7 @@ export interface RegressionSyncConfig {
   provider?: "github";
   mode?: "off" | "warn" | "error";
   cacheTtlSeconds?: number;
+  apiBaseUrl?: string;
 }
 
 export interface RegressionSyncFinding {
@@ -61,7 +77,7 @@ export interface RegressionSyncFinding {
 export interface RegressionSyncEntry {
   id: string;
   summary: string;
-  issue: RegressionIssueRef;
+  issue: RegressionIssueRef | null;
   observed: {
     matchedTests: number;
     executedTests: number;
@@ -99,41 +115,52 @@ export interface RegressionSyncResult {
   };
   findings: RegressionSyncFinding[];
   summary: {
-    entries: number;
-    observedEntries: number;
+    cases: number;
+    observedCases: number;
     errors: number;
     warnings: number;
     byCode: Record<string, number>;
     byStatus: Record<string, number>;
   };
-  entries: RegressionSyncEntry[];
+  cases: RegressionSyncEntry[];
 }
 
-export declare function loadRegressionCatalogConfig(
+export declare function loadRegressionCaseStoreConfig(
   productDir: string,
   config: { file?: string | null } | null
-): RegressionCatalogDocument | null;
-export declare function loadRegressionCatalogDocument(
+): RegressionCaseStoreDocument | null;
+export declare function loadRegressionCaseStoreDocument(
   filePath: string,
   relativePath?: string
-): RegressionCatalogDocument;
-export declare function normalizeRegressionCatalogDocument(
+): RegressionCaseStoreDocument;
+export declare function writeRegressionCaseStoreDocument(
+  filePath: string,
+  document: RegressionCaseStoreDocument
+): void;
+export declare function serializeRegressionCaseStore(
+  document: RegressionCaseStoreDocument
+): {
+  schemaVersion: 2;
+  issueRepo?: string | null;
+  cases: RegressionCase[];
+};
+export declare function normalizeRegressionCaseStoreDocument(
   document: unknown,
   relativePath?: string
-): RegressionCatalogDocument;
-export declare function validateRegressionCatalogDocument(
-  document: RegressionCatalogDocument,
+): RegressionCaseStoreDocument;
+export declare function validateRegressionCaseStoreDocument(
+  document: RegressionCaseStoreDocument,
   options?: {
     productDir?: string;
     statusArtifactPath?: string;
     statusArtifact?: unknown;
   }
-): RegressionCatalogValidationResult;
-export declare function renderRegressionCatalogMarkdown(
-  document: RegressionCatalogDocument
+): RegressionCaseStoreValidationResult;
+export declare function renderRegressionCaseStoreMarkdown(
+  document: RegressionCaseStoreDocument
 ): string;
-export declare function findMatchingRegressionEntries(
-  document: RegressionCatalogDocument,
+export declare function findMatchingRegressionCases(
+  document: RegressionCaseStoreDocument,
   fileSummary: {
     service?: string;
     type?: string;
@@ -142,9 +169,9 @@ export declare function findMatchingRegressionEntries(
     error?: string | null;
     failureDetails?: Array<{ key?: string; title?: string }>;
   }
-): RegressionCatalogEntry[];
-export declare function matchesRegressionEntry(
-  entry: RegressionCatalogEntry,
+): RegressionCase[];
+export declare function matchesRegressionCase(
+  entry: RegressionCase,
   fileSummary: {
     service?: string;
     type?: string;
@@ -158,6 +185,7 @@ export declare function buildRegressionFileIdentity(
   type: string,
   filePath: string
 ): string;
+export declare function issueRefToString(issue: RegressionIssueRef | null): string | null;
 
 export declare function normalizeRegressionSyncConfig(
   value: unknown
@@ -165,10 +193,11 @@ export declare function normalizeRegressionSyncConfig(
   provider: "github";
   mode: "off" | "warn" | "error";
   cacheTtlSeconds: number;
+  apiBaseUrl: string | null;
 } | null;
 export declare function validateRegressionIssues(options: {
   productDir: string;
-  document: RegressionCatalogDocument | null;
+  document: RegressionCaseStoreDocument | null;
   runArtifact?: unknown;
   statusArtifact?: unknown;
   config?: RegressionSyncConfig | null;