@ecoma-io/archkeep 0.13.0 → 0.14.0

package/src/report/text.mjs

@@ -588,6 +588,7 @@ const UNOWNED_SAMPLE_LIMIT = 10;
 function formatCoverageGap(gap) {
   if (gap.kind === "unregistered-plugin") return formatUnregisteredPluginGap(gap);
   if (gap.kind === "unowned-files") return formatUnownedFilesGap(gap);
+  if (gap.kind === "accepted-unowned-files") return formatAcceptedUnownedFilesGap(gap);
   return `⚠ coverage gap "${gap.kind}" — part of this workspace is outside what this run covered`;
 }
 
@@ -655,6 +656,41 @@ function formatUnownedFilesGap(gap) {
   );
 }
 
+/**
+ * The accepted counterpart of the gap above: unowned files the boundary
+ * policy's `coverage.unowned` rows accept (`../commands/check.mjs`,
+ * `../commands/coverage-acceptance.mjs`). An accepted hole is still a hole,
+ * so the section renders on every run the acceptance is in force, with the
+ * same bounded sample the warning uses — what it no longer does is ask the
+ * reader a question someone already answered, which is the warning's job.
+ * The reasons live on the accepting rows, and `archkeep waivers` is the
+ * surface that names each row with its reason and current coverage; this
+ * face points there rather than restating them.
+ *
+ * @param {{languages?: string[], files: string[]}} gap
+ * @returns {string}
+ */
+function formatAcceptedUnownedFilesGap(gap) {
+  const files = gap.files ?? [];
+  const count = files.length;
+  const languages = gap.languages ?? [];
+  const spans = languages.length > 0 ? ` (${languages.join(", ")})` : "";
+  const shown = files.slice(0, UNOWNED_SAMPLE_LIMIT);
+  const remaining = count - shown.length;
+  const lines = shown.map((file) => `${CONTINUED}${file}`);
+  if (remaining > 0) {
+    lines.push(`${CONTINUED}… and ${remaining} more — the full list is in --format json`);
+  }
+  const them = count === 1 ? "it" : "them";
+  return (
+    `⚠ ${count} tracked analyzable file${count === 1 ? "" : "s"}${spans} ` +
+    `owned by no project — accepted as coverage holes by the policy's coverage.unowned, ` +
+    `so no boundary verdict covers ${them}\n` +
+    `${lines.join("\n")}\n` +
+    `${DETAIL}each accepting row's reason: archkeep waivers`
+  );
+}
+
 /**
  * The policy-identity line — which law this run enforced — rendered FIRST,
  * ahead of every verdict below it: a reader has to know WHICH law produced a

package/src/report/waivers-text.mjs

@@ -16,7 +16,11 @@
 
 /**
  * @param {{waivers: object[], covered: number, expired: number, stale: number,
- *   suppressions: object[], suppressed: number}} result
+ *   suppressions: object[], suppressed: number,
+ *   unownedAcceptances?: {path: string, reason: string, covered: number}[]}} result
+ *   `unownedAcceptances` is present exactly when the policy declares
+ *   `coverage.unowned` (`../commands/waivers.mjs`) — the third surface, and
+ *   the one the acceptances' reasons live on.
  * @returns {string}
  */
 export function formatWaiversReport({
@@ -26,10 +30,17 @@ export function formatWaiversReport({
   stale,
   suppressions,
   suppressed,
+  unownedAcceptances,
 }) {
   const sections = [];
+  const acceptances = unownedAcceptances ?? [];
 
-  if (waivers.length === 0 && suppressions.length === 0) {
+  if (waivers.length === 0 && suppressions.length === 0 && acceptances.length === 0) {
+    // The all-empty claim may only be made when all THREE surfaces were
+    // measured and found empty — a declared `coverage.unowned` row is an
+    // acceptance on the table exactly as a suppression is, and this line
+    // reading "nothing is accepted" over one would be the module header's
+    // defect on a third table.
     return `no waivers — every boundary is enforced, nothing is being accepted temporarily or permanently`;
   }
 
@@ -96,5 +107,27 @@ export function formatWaiversReport({
     }
   }
 
+  if (acceptances.length > 0) {
+    // The coverage half of the table: each row accepts unowned FILES rather
+    // than a verdict — `check` still states the files as an accepted
+    // coverage gap, and this section is where their reasons live
+    // (`../commands/coverage-acceptance.mjs`). A row covering nothing is
+    // named the way a stale waiver is; `check` refuses it outright.
+    const totalCovered = acceptances.reduce((sum, row) => sum + row.covered, 0);
+    sections.push(
+      `${acceptances.length} coverage acceptance${acceptances.length === 1 ? "" : "s"} ` +
+        `(coverage.unowned) on the table — currently accepting ${totalCovered} unowned ` +
+        `file${totalCovered === 1 ? "" : "s"} as recorded coverage holes`,
+    );
+
+    for (const row of acceptances) {
+      const coverage =
+        row.covered === 0
+          ? "covers no unowned file right now — the files it accepted may be owned by a project now"
+          : `currently covers ${row.covered} unowned file${row.covered === 1 ? "" : "s"}`;
+      sections.push([`- ${row.path}: ${coverage}`, `  reason: ${row.reason}`].join("\n"));
+    }
+  }
+
   return sections.join("\n\n");
 }