@elench/testkit 0.1.150 → 0.1.151

package/lib/regressions/github-transport.mjs

@@ -19,13 +19,26 @@ export function parseGitHubRepoSlug(remoteUrl) {
   return null;
 }
 
-export async function createDefaultGitHubIssueTransport(env = process.env) {
+export async function createDefaultGitHubIssueTransport(env = process.env, options = {}) {
   const token = env.GH_TOKEN || env.GITHUB_TOKEN || null;
+  const apiBaseUrl = normalizeOptionalString(options.apiBaseUrl || env.TESTKIT_GITHUB_API_URL) || "https://api.github.com";
   if (token) {
     return {
       type: "token",
       async fetchRepoIssues(repo, numbers) {
-        return fetchRepoIssuesViaToken(repo, numbers, token);
+        return fetchRepoIssuesViaToken(repo, numbers, token, { apiBaseUrl });
+      },
+      async fetchOpenBugIssues(repo, options = {}) {
+        return fetchOpenBugIssuesViaRest(repo, token, { apiBaseUrl, ...options });
+      },
+      async createIssue(repo, input) {
+        return createIssueViaRest(repo, input, token, { apiBaseUrl });
+      },
+      async updateIssueState(repo, number, state) {
+        return updateIssueStateViaRest(repo, number, state, token, { apiBaseUrl });
+      },
+      async createIssueComment(repo, number, body) {
+        return createIssueCommentViaRest(repo, number, body, token, { apiBaseUrl });
       },
     };
   }
@@ -41,6 +54,18 @@ export async function createDefaultGitHubIssueTransport(env = process.env) {
       async fetchRepoIssues(repo, numbers) {
         return fetchRepoIssuesViaGh(repo, numbers, env);
       },
+      async fetchOpenBugIssues(repo, options = {}) {
+        return fetchOpenBugIssuesViaGh(repo, options, env);
+      },
+      async createIssue(repo, input) {
+        return createIssueViaGh(repo, input, env);
+      },
+      async updateIssueState(repo, number, state) {
+        return updateIssueStateViaGh(repo, number, state, env);
+      },
+      async createIssueComment(repo, number, body) {
+        return createIssueCommentViaGh(repo, number, body, env);
+      },
     };
   } catch {
     return null;
@@ -65,9 +90,9 @@ export async function fetchIssuesByRepo(client, issueNumbersByRepo) {
   return issuesByRepo;
 }
 
-async function fetchRepoIssuesViaToken(repo, numbers, token) {
+async function fetchRepoIssuesViaToken(repo, numbers, token, { apiBaseUrl = "https://api.github.com" } = {}) {
   const query = buildIssueQuery(repo, numbers);
-  const response = await fetch("https://api.github.com/graphql", {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/graphql`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -90,6 +115,61 @@ async function fetchRepoIssuesViaToken(repo, numbers, token) {
   return normalizeGraphqlIssuesResponse(repo, numbers, payload?.data);
 }
 
+async function fetchOpenBugIssuesViaRest(repo, token, { apiBaseUrl = "https://api.github.com", labels = ["bug"] } = {}) {
+  const labelQuery = labels.length > 0 ? `&labels=${encodeURIComponent(labels.join(","))}` : "";
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues?state=open${labelQuery}`, {
+    headers: githubRestHeaders(token),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue list failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return normalizeRestIssues(repo, Array.isArray(payload) ? payload : []);
+}
+
+async function createIssueViaRest(repo, input, token, { apiBaseUrl = "https://api.github.com" } = {}) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues`, {
+    method: "POST",
+    headers: githubRestHeaders(token),
+    body: JSON.stringify({
+      title: input.title,
+      body: input.body,
+      labels: input.labels || [],
+    }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue create failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return normalizeRestIssue(repo, payload);
+}
+
+async function updateIssueStateViaRest(repo, number, state, token, { apiBaseUrl = "https://api.github.com" } = {}) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues/${number}`, {
+    method: "PATCH",
+    headers: githubRestHeaders(token),
+    body: JSON.stringify({ state }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue update failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return normalizeRestIssue(repo, payload);
+}
+
+async function createIssueCommentViaRest(repo, number, body, token, { apiBaseUrl = "https://api.github.com" } = {}) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues/${number}/comments`, {
+    method: "POST",
+    headers: githubRestHeaders(token),
+    body: JSON.stringify({ body }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue comment failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return payload;
+}
+
 async function fetchRepoIssuesViaGh(repo, numbers, env) {
   const query = buildIssueQuery(repo, numbers);
   const { stdout } = await execFileAsync("gh", ["api", "graphql", "-f", `query=${query}`], {
@@ -104,6 +184,65 @@ async function fetchRepoIssuesViaGh(repo, numbers, env) {
   return normalizeGraphqlIssuesResponse(repo, numbers, payload?.data);
 }
 
+async function fetchOpenBugIssuesViaGh(repo, { labels = ["bug"] } = {}, env) {
+  const args = ["issue", "list", "--repo", repo, "--state", "open", "--json", "number,title,state,url,labels"];
+  for (const label of labels) args.push("--label", label);
+  const { stdout } = await execFileAsync("gh", args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  return normalizeRestIssues(repo, JSON.parse(stdout || "[]"));
+}
+
+async function createIssueViaGh(repo, input, env) {
+  const args = ["issue", "create", "--repo", repo, "--title", input.title, "--body", input.body || ""];
+  for (const label of input.labels || []) args.push("--label", label);
+  const { stdout } = await execFileAsync("gh", args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  const url = stdout.trim();
+  const number = Number(url.match(/\/issues\/(\d+)$/u)?.[1]);
+  return {
+    repo,
+    number,
+    exists: Number.isInteger(number),
+    title: input.title,
+    state: "OPEN",
+    url,
+    labels: input.labels || [],
+    source: "github",
+  };
+}
+
+async function updateIssueStateViaGh(repo, number, state, env) {
+  await execFileAsync("gh", ["issue", state === "open" ? "reopen" : "close", String(number), "--repo", repo], {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  return {
+    repo,
+    number,
+    exists: true,
+    title: null,
+    state: state.toUpperCase(),
+    url: `https://github.com/${repo}/issues/${number}`,
+    source: "github",
+  };
+}
+
+async function createIssueCommentViaGh(repo, number, body, env) {
+  await execFileAsync("gh", ["issue", "comment", String(number), "--repo", repo, "--body", body], {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  return { ok: true };
+}
+
 function buildIssueQuery(repo, numbers) {
   const [owner, name] = repo.split("/");
   return `
@@ -159,6 +298,41 @@ function normalizeGraphqlIssuesResponse(repo, numbers, data) {
   return map;
 }
 
+function normalizeRestIssues(repo, issues) {
+  const map = new Map();
+  for (const issue of issues) {
+    const normalized = normalizeRestIssue(repo, issue);
+    if (normalized?.number) map.set(normalized.number, normalized);
+  }
+  return map;
+}
+
+function normalizeRestIssue(repo, issue) {
+  if (!issue || typeof issue !== "object") return null;
+  return {
+    repo,
+    number: Number(issue.number),
+    exists: true,
+    title: normalizeOptionalString(issue.title),
+    state: normalizeOptionalString(issue.state)?.toUpperCase() || null,
+    url: normalizeOptionalString(issue.html_url || issue.url),
+    labels: Array.isArray(issue.labels)
+      ? issue.labels.map((label) => typeof label === "string" ? label : label?.name).filter(Boolean)
+      : [],
+    checkedAt: null,
+    source: "github",
+  };
+}
+
+function githubRestHeaders(token) {
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/vnd.github+json",
+    Authorization: `Bearer ${token}`,
+    "X-GitHub-Api-Version": "2022-11-28",
+  };
+}
+
 function normalizeOptionalString(value) {
   if (typeof value !== "string") return null;
   const normalized = value.trim();

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;
@@ -19,27 +29,31 @@ export interface RegressionFingerprint {
   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;
@@ -51,6 +65,7 @@ export interface RegressionSyncConfig {
   provider?: "github";
   mode?: "off" | "warn" | "error";
   cacheTtlSeconds?: number;
+  apiBaseUrl?: string;
 }
 
 export interface RegressionSyncFinding {
@@ -62,7 +77,7 @@ export interface RegressionSyncFinding {
 export interface RegressionSyncEntry {
   id: string;
   summary: string;
-  issue: RegressionIssueRef;
+  issue: RegressionIssueRef | null;
   observed: {
     matchedTests: number;
     executedTests: number;
@@ -100,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;
@@ -143,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;
@@ -159,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
@@ -166,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;