executable-stories-formatters 1.20.0 → 1.21.1

package/dist/index.cjs

@@ -87,6 +87,7 @@ __export(src_exports, {
   computeTestMetrics: () => computeTestMetrics,
   copyMarkdownAssets: () => copyMarkdownAssets,
   createAnchor: () => createAnchor,
+  createJevClient: () => createJevClient,
   createPrCommentSummary: () => createPrCommentSummary,
   createReportGenerator: () => createReportGenerator,
   createTestRailProvider: () => createTestRailProvider,
@@ -99,6 +100,9 @@ __export(src_exports, {
   diffRuns: () => diffRuns,
   diffStoryReports: () => diffStoryReports,
   emptyLockfile: () => emptyLockfile,
+  enrichGoal: () => enrichGoal,
+  enrichReview: () => enrichReview,
+  enrichTriage: () => enrichTriage,
   findGitDir: () => findGitDir,
   formatDuration: () => import_duration2.formatDuration,
   generateRunComparison: () => generateRunComparison,
@@ -113,6 +117,7 @@ __export(src_exports, {
   isProviderName: () => isProviderName,
   isReviewableSource: () => isReviewableSource,
   isTestFile: () => isTestFile,
+  jevFromEnv: () => jevFromEnv,
   joinNameAndExt: () => joinNameAndExt,
   listScenarios: () => listScenarios,
   loadHistory: () => loadHistory,
@@ -5146,6 +5151,50 @@ function sourceBaseKey(sourceFile) {
   return dot > slash ? sourceFile.slice(0, dot) : sourceFile;
 }
 
+// src/jev.ts
+var JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+var JEV_MODEL = "jev-latest";
+function createJevClient(options) {
+  const {
+    apiKey,
+    model = JEV_MODEL,
+    endpoint = JEV_ENDPOINT,
+    fetch = globalThis.fetch,
+    timeoutMs = 1e4
+  } = options;
+  return {
+    model,
+    // One attempt per question set; add backoff on 429/529 if a loop hits rate limits.
+    async ask(state, questions) {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify({ model, state, questions }),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!response.ok) throw new Error(`Jev ${response.status}: ${(await response.text()).slice(0, 200)}`);
+      const body = await response.json();
+      if (!body.answers) throw new Error("Jev response has no answers");
+      return body.answers;
+    }
+  };
+}
+function jevFromEnv(env = process.env) {
+  const apiKey = env.JEV_API_KEY;
+  if (!apiKey) return void 0;
+  return createJevClient({
+    apiKey,
+    ...env.JEV_MODEL ? { model: env.JEV_MODEL } : {},
+    ...env.JEV_ENDPOINT ? { endpoint: env.JEV_ENDPOINT } : {}
+  });
+}
+function asChoice(answer) {
+  return answer?.type === "choice" ? answer : void 0;
+}
+function asNoul(answer) {
+  return answer?.type === "noul" ? answer.noul : void 0;
+}
+
 // src/review/build-review.ts
 var STRENGTH_RANK = {
   none: 0,
@@ -5346,6 +5395,61 @@ function buildReview(run, context = { changedFiles: [] }) {
     codeDiffs: (context.codeDiffs ?? []).map((d) => buildCodeDiff(d, run, context))
   };
 }
+var REVIEW_CHANGE_TYPE_MIN_CONFIDENCE = 0.6;
+var PATCH_EXCERPT_CHARS = 4e3;
+var CHANGE_TYPE_CRITERIA = {
+  feature: "new user-visible behaviour or capability",
+  bugfix: "corrects behaviour that was wrong",
+  refactor: "restructures code without changing behaviour",
+  perf: "same behaviour, faster or cheaper",
+  deps: "dependency, toolchain, or lockfile change"
+};
+async function enrichReview(review, jev) {
+  const untagged = review.claims.filter((c) => c.changeType === "unknown" && c.coversFiles.length > 0);
+  if (untagged.length === 0) return review;
+  const hunksByPath = /* @__PURE__ */ new Map();
+  for (const group of review.context.codeDiffs ?? []) {
+    for (const file of parseUnifiedDiff(group.patch)) {
+      const path15 = file.newPath ?? file.oldPath;
+      if (!path15) continue;
+      const text2 = file.hunks.flatMap((h) => h.lines.map((l) => (l.kind === "add" ? "+" : l.kind === "del" ? "-" : " ") + l.text));
+      hunksByPath.set(path15, [...hunksByPath.get(path15) ?? [], ...text2]);
+    }
+  }
+  const inferred = /* @__PURE__ */ new Map();
+  await Promise.all(
+    untagged.map(async (claim) => {
+      const patch = claim.coversFiles.flatMap((f) => hunksByPath.get(f) ?? []).join("\n").slice(0, PATCH_EXCERPT_CHARS);
+      const answers = await jev.ask(
+        {
+          scenario: claim.scenario,
+          steps: claim.testCase.story.steps.map((s) => `${s.keyword} ${s.text}`),
+          ...claim.intent ? { intent: claim.intent } : {},
+          changedFiles: claim.coversFiles,
+          ...patch ? { patch } : {}
+        },
+        {
+          changeType: {
+            type: "choice",
+            instructions: "What kind of change does this scenario prove?",
+            criteria: CHANGE_TYPE_CRITERIA
+          }
+        }
+      );
+      const answer = asChoice(answers.changeType);
+      if (!answer || answer.confidence < REVIEW_CHANGE_TYPE_MIN_CONFIDENCE) return;
+      const changeType = answer.choice;
+      if (VALID_CHANGE_TYPES.has(changeType)) inferred.set(claim.id, { changeType, confidence: answer.confidence });
+    })
+  );
+  return {
+    ...review,
+    claims: review.claims.map((claim) => {
+      const hit = inferred.get(claim.id);
+      return hit ? { ...claim, changeType: hit.changeType, changeTypeConfidence: hit.confidence } : claim;
+    })
+  };
+}
 function codeDiffDiagnostics(review) {
   const issues = [];
   for (const evidence of review.codeDiffs) {
@@ -9679,9 +9783,41 @@ function buildGoal(args, _deps = {}) {
     requirements,
     regressions,
     regressionsEnforced: Boolean(baseline && args.enforceNoRegressions),
-    ratchet: { enforced: Boolean(baseline && args.enforceRatchet), violations }
+    ratchet: { enforced: Boolean(baseline && args.enforceRatchet), violations, advisories: [] }
   };
 }
+var GOAL_WEAKENED_MIN_PROBABILITY = 0.75;
+var stepText = (tc) => tc.story.steps.map((s) => `${s.keyword} ${s.text}`);
+async function enrichGoal(report, args, jev) {
+  const { baseline } = args;
+  if (!baseline || !report.ratchet.enforced) return report;
+  const current = new Map(args.run.testCases.map((tc) => [tc.id, tc]));
+  const flagged = new Set(report.ratchet.violations.map((v) => v.id));
+  const rewritten = baseline.testCases.flatMap((base) => {
+    const now = current.get(base.id);
+    if (!now || flagged.has(base.id)) return [];
+    const before = stepText(base);
+    const after = stepText(now);
+    return before.join("\n") === after.join("\n") ? [] : [{ base, before, after }];
+  });
+  const advisories = (await Promise.all(
+    rewritten.map(async ({ base, before, after }) => {
+      const answers = await jev.ask(
+        { baseline: before, now: after },
+        {
+          weakened: {
+            type: "noul",
+            instructions: "Does the NOW scenario check less than the BASELINE scenario: fewer or weaker assertions, looser expectations, or a removed check?"
+          }
+        }
+      );
+      const p = asNoul(answers.weakened);
+      if (p === void 0 || p < GOAL_WEAKENED_MIN_PROBABILITY) return [];
+      return [{ id: base.id, title: base.story.scenario, kind: "weakened", detail: `jev ${p.toFixed(2)}: steps rewritten, checks less` }];
+    })
+  )).flat();
+  return { ...report, ratchet: { ...report.ratchet, advisories } };
+}
 function evaluate(selector, matched) {
   const passed = matched.filter((tc) => tc.status === "passed").length;
   const failing = matched.filter((tc) => tc.status !== "passed").map((tc) => tc.story.scenario);
@@ -9723,6 +9859,9 @@ function renderGoal(report, format) {
         lines.push(`    ${v.kind}: ${v.title} (${v.detail})`);
       }
     }
+    for (const v of report.ratchet.advisories) {
+      lines.push(`    advisory ${v.kind}: ${v.title} (${v.detail})`);
+    }
   }
   return lines.join("\n");
 }
@@ -9792,6 +9931,55 @@ function buildTriage(args, _deps = {}) {
     items
   };
 }
+var TRIAGE_SUGGEST_MIN_PROBABILITY = 0.5;
+var FAILURE_KIND_CRITERIA = {
+  product: "the application code under test behaves wrongly",
+  test: "the scenario, assertion, fixture, or test data is wrong or stale",
+  infra: "environment, network, timeout, resource, or flaky-timing failure"
+};
+async function enrichTriage(report, testCases, jev, codeowners) {
+  const candidates = new Set(testCases.flatMap((tc) => tc.story.covers ?? []));
+  for (const rule of codeowners ?? []) candidates.add(rule.pattern);
+  const criteria = Object.fromEntries([...candidates].map((path15) => [path15, null]));
+  const byId = new Map(testCases.map((tc) => [tc.id, tc]));
+  const items = await Promise.all(
+    report.items.map(async (item) => {
+      if (item.covers.length > 0) return item;
+      const tc = byId.get(item.id);
+      const answers = await jev.ask(
+        {
+          scenario: item.scenario,
+          steps: tc?.story.steps.map((s) => `${s.keyword} ${s.text}`) ?? [],
+          testFile: item.location,
+          error: item.errorMessage ?? null
+        },
+        {
+          kind: {
+            type: "choice",
+            instructions: "What is most likely broken, given this failing scenario and its error?",
+            criteria: FAILURE_KIND_CRITERIA
+          },
+          ...candidates.size > 0 ? {
+            covers: {
+              type: "choice",
+              instructions: "Which of these product paths does the fix for this failure most likely land in?",
+              criteria
+            }
+          } : {}
+        }
+      );
+      const kind = asChoice(answers.kind);
+      const covers = asChoice(answers.covers);
+      const probability = covers ? covers.probabilities[covers.choice] ?? 0 : 0;
+      return {
+        ...item,
+        ...kind && kind.choice in FAILURE_KIND_CRITERIA ? { failureKind: { kind: kind.choice, confidence: kind.confidence } } : {},
+        ...covers && probability >= TRIAGE_SUGGEST_MIN_PROBABILITY ? { suggestedCovers: { path: covers.choice, probability } } : {}
+      };
+    })
+  );
+  return { ...report, items };
+}
 function renderTriage(report, format, options = {}) {
   if (format === "json") return JSON.stringify(report, null, 2);
   if (report.items.length === 0) {
@@ -9809,9 +9997,14 @@ function renderTriage(report, format, options = {}) {
     }
     if (item.covers.length > 0) {
       lines.push(`   fix: ${item.covers.join(", ")}`);
+    } else if (item.suggestedCovers) {
+      lines.push(`   fix: ${item.suggestedCovers.path}? (jev ${item.suggestedCovers.probability.toFixed(2)}, no covers declared)`);
     } else {
       lines.push("   fix: (no covers declared \u2014 add `covers` to route this to code)");
     }
+    if (item.failureKind) {
+      lines.push(`   kind: ${item.failureKind.kind} (jev ${item.failureKind.confidence.toFixed(2)})`);
+    }
     if (item.tickets.length > 0) {
       lines.push(`   ticket: ${item.tickets.join(", ")}`);
     }
@@ -10062,7 +10255,8 @@ function renderClaim(lines, claim) {
   lines.push("");
   lines.push(`- File: \`${claim.sourceFile}:${claim.sourceLine}\``);
   if (claim.changeType !== "unknown") {
-    lines.push(`- Change: \`${claim.changeType}\``);
+    const inferred = claim.changeTypeConfidence === void 0 ? "" : ` _(inferred, jev ${claim.changeTypeConfidence.toFixed(2)})_`;
+    lines.push(`- Change: \`${claim.changeType}\`${inferred}`);
   }
   const tickets = claim.testCase.story.tickets ?? [];
   if (tickets.length > 0) {
@@ -10784,6 +10978,7 @@ function normalizePlaywrightResults(testResults, adapterOptions, canonicalizeOpt
   computeTestMetrics,
   copyMarkdownAssets,
   createAnchor,
+  createJevClient,
   createPrCommentSummary,
   createReportGenerator,
   createTestRailProvider,
@@ -10796,6 +10991,9 @@ function normalizePlaywrightResults(testResults, adapterOptions, canonicalizeOpt
   diffRuns,
   diffStoryReports,
   emptyLockfile,
+  enrichGoal,
+  enrichReview,
+  enrichTriage,
   findGitDir,
   formatDuration,
   generateRunComparison,
@@ -10810,6 +11008,7 @@ function normalizePlaywrightResults(testResults, adapterOptions, canonicalizeOpt
   isProviderName,
   isReviewableSource,
   isTestFile,
+  jevFromEnv,
   joinNameAndExt,
   listScenarios,
   loadHistory,