canary-test-cli 6.1.0 → 6.3.0

package/dist/engine/guardian/pr-check.js

@@ -28,7 +28,7 @@ import { readFileSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { readJsonWithWarning } from '../core/config-validation.js';
 import { isAssertionFreeTest } from '../core/quality-scorer.js';
-import { Fidelity, isTestPath, } from './coverage.js';
+import { Fidelity, isSourcePath, isTestPath, } from './coverage.js';
 import { Severity, severitySortKey } from './impact-mapper.js';
 const HUNK_RE = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/;
 // Suppression annotation: `// canary:allow-untested <reason>` or the `#`
@@ -359,6 +359,58 @@ export function filterTestUnits(units) {
     }
     return [kept, testUnits];
 }
+/**
+ * Default glob layer over the {@link isSourcePath} extension floor (#413).
+ *
+ * These paths carry a *source* extension but still have nothing a naming
+ * heuristic could judge: ambient type declarations have no runtime behavior,
+ * and generated clients/stubs are regenerated from a schema rather than
+ * hand-authored. An explicit `heuristicExclude` in config (even `[]`) replaces
+ * this list; the extension floor is NOT config-defeatable.
+ */
+export const DEFAULT_HEURISTIC_EXCLUDE_GLOBS = [
+    '**/*.d.ts',
+    '**/__generated__/**',
+    '**/generated/**',
+    '**/*.generated.*',
+    '**/*_pb2.py',
+    '**/*.pb.go',
+];
+/**
+ * Partition coverage results, dropping heuristic false positives (#413).
+ *
+ * A result is dropped iff ALL of:
+ *
+ *   - its fidelity is `HEURISTIC` (the last-resort naming tier), AND
+ *   - it is **uncovered** (a covered result raises no finding anyway), AND
+ *   - its path is not program source ({@link isSourcePath}) OR it matches an
+ *     `excludeGlobs` entry.
+ *
+ * The narrowness is the point. A `COVERAGE_VERIFIED` or `GRAPH_VERIFIED`
+ * verdict on the very same path rests on real evidence (an lcov row, a graph
+ * edge) and still fires — the suppression is scoped to the tier, never to the
+ * path. Returns `[kept, dropped]`, order-preserving in both.
+ *
+ * Why this matters beyond noise: the soft→hard gate promotion is earned by
+ * reviewer adjudication feeding `precision = TP / (TP + FP)`. A repo that
+ * routinely touches config files accumulated 👎 on findings that could never
+ * have been true, holding it below its promotion bar indefinitely.
+ */
+export function filterHeuristicNoise(results, excludeGlobs) {
+    const kept = [];
+    const dropped = [];
+    for (const result of results) {
+        const ineligible = result.fidelity === Fidelity.Heuristic &&
+            !result.covered &&
+            (!isSourcePath(result.unit.path) ||
+                excludeGlobs.some((glob) => globMatches(result.unit.path, glob)));
+        if (ineligible)
+            dropped.push(result);
+        else
+            kept.push(result);
+    }
+    return [kept, dropped];
+}
 /**
  * A single guardian finding about a changed unit.
  *
@@ -612,6 +664,46 @@ export function computeExitCode(findings, gate) {
     return 0;
 }
 const STICKY_MARKER = '<!-- canary-pr-guardian -->';
+// Severity → status icon for the sticky comment (encodes severity in form, not
+// just text, so the most urgent findings read at a glance).
+//
+// Written as `\u{...}` escapes, not literal glyphs: this file is `.ts`, and the
+// house rule keeps emitted non-ASCII out of non-Markdown source (see the
+// "Output data glyphs" block in `cli.ts`). They are emitted verbatim.
+/**
+ * Character budget for a rendered sticky comment (#457).
+ *
+ * GitHub rejects an issue/PR comment body over **65,536** characters. The post
+ * path reports that as "could not post", so an over-long body means the gate
+ * silently produces nothing on exactly the large PRs that need it most -- the
+ * same silent-green failure #369 was filed for.
+ *
+ * 60,000 leaves ~5.5k of headroom for anything appended outside `render`
+ * (degradation annotations, upsert wrappers) without inviting a body that only
+ * *just* fits and then breaks when a filename grows.
+ *
+ * The cap applies ONLY to the comment. The `--emit-analysis` JSON record is the
+ * authoritative complete set and is never truncated.
+ */
+export const COMMENT_CHAR_BUDGET = 60_000;
+/** The line that accounts for findings the budget could not fit (#457). */
+function overflowNote(omitted) {
+    return (`<sub>${EM_DASH} and ${omitted} more finding(s) omitted to keep this ` +
+        `comment under GitHub's size limit. The full set is in the analysis ` +
+        `record (\`--emit-analysis\`) and the CI logs.</sub>`);
+}
+const EM_DASH = '\u{2014}';
+const RED_CIRCLE = '\u{1F534}';
+const YELLOW_CIRCLE = '\u{1F7E1}';
+const WHITE_CIRCLE = '\u{26AA}';
+const BABY_CHICK = '\u{1F424}';
+const WHITE_CHECK = '\u{2705}';
+const SEVERITY_ICON = {
+    [Severity.CRITICAL]: RED_CIRCLE,
+    [Severity.HIGH]: RED_CIRCLE,
+    [Severity.MEDIUM]: YELLOW_CIRCLE,
+    [Severity.LOW]: WHITE_CIRCLE,
+};
 /**
  * Escape every non-ASCII (>= U+0080) code unit to a `\uXXXX` sequence, matching
  * Python's `json.dumps(..., ensure_ascii=True)` (the library default). `JSON`
@@ -661,33 +753,79 @@ export function render(findings, fmt, tier = 0, degradedNotice = null) {
     }
     const active = ordered.filter((f) => !f.suppressed);
     const suppressed = ordered.filter((f) => f.suppressed);
+    // A finding's file label shows the path once, appending the unit only when
+    // it is a distinct symbol within the file (never `path (path)`).
+    const fileLabel = (f) => f.unit && f.unit !== f.path
+        ? `\`${f.path}\` → \`${f.unit}\``
+        : `\`${f.path}\``;
+    const cell = (s) => s.replace(/\|/g, '\\|');
+    const CONFIDENCE_NOTE = 'Confidence — **coverage-verified**: measured from a real coverage run · ' +
+        '**graph-verified**: inferred from the call graph · **heuristic**: filename ' +
+        `guess (lowest). tier ${tier}: deterministic check, no LLM.`;
+    const footerLine = `<sub>${CONFIDENCE_NOTE}${degradedNotice ? ` ${EM_DASH} ${degradedNotice}` : ''}</sub>`;
     if (fmt === 'comment') {
-        const lines = [STICKY_MARKER, '## Canary PR Guardian'];
-        lines.push(`**${active.length} unaddressed** / ${suppressed.length} suppressed ` +
-            `finding(s) — fidelity-labeled below.`);
-        for (const finding of ordered) {
-            const mark = finding.suppressed ? ' _(suppressed)_' : '';
-            lines.push(`- **${finding.severity}** \`${finding.path}\` ` +
-                `(${finding.unit}) — _${finding.fidelity}_ — ` +
-                `${finding.evidence}${mark}`);
-        }
-        let footer = `_tier ${tier}_`;
-        if (degradedNotice)
-            footer += ` — ${degradedNotice}`;
-        lines.push(footer);
+        const fileCount = new Set(active.map((f) => f.path)).size;
+        const lines = [STICKY_MARKER];
+        if (active.length === 0) {
+            lines.push(`## ${BABY_CHICK} Canary PR Guardian ${EM_DASH} ` +
+                `${WHITE_CHECK} no test-coverage gaps`);
+            if (suppressed.length) {
+                lines.push(`_${suppressed.length} finding(s) suppressed as intentional._`);
+            }
+        }
+        else {
+            const noun = fileCount === 1 ? 'file needs' : 'files need';
+            lines.push(`## ${BABY_CHICK} Canary PR Guardian ${EM_DASH} ` +
+                `${fileCount} ${noun} test coverage`);
+            lines.push('These lines were changed by this PR but no test exercises them. Add or ' +
+                'extend a test that covers them, or reply ' +
+                '`/guardian suppress <file> <reason>` if they are intentionally untested.');
+            lines.push('', '| Sev | File | What is uncovered | Confidence |', '| --- | --- | --- | --- |');
+            // #457: fill rows against a character budget instead of emitting all of
+            // them. `active` is already severity-ordered, so the rows that survive
+            // are the most severe -- a critical finding is never dropped to make room
+            // for a low one.
+            const suppressedNote = suppressed.length
+                ? `\n\n<sub>${suppressed.length} finding(s) suppressed as intentional and not counted above.</sub>`
+                : '';
+            // Reserved so the tail always fits: footer, suppressed note, and a
+            // worst-case overflow line (the real one is shorter).
+            const reserve = footerLine.length +
+                suppressedNote.length +
+                overflowNote(active.length).length +
+                4;
+            let used = lines.join('\n').length;
+            let shown = 0;
+            for (const f of active) {
+                const row = `| ${SEVERITY_ICON[f.severity] ?? ''} ${f.severity} | ${cell(fileLabel(f))} | ${cell(f.evidence)} | ${f.fidelity} |`;
+                if (used + row.length + 1 + reserve > COMMENT_CHAR_BUDGET)
+                    break;
+                lines.push(row);
+                used += row.length + 1;
+                shown += 1;
+            }
+            const omitted = active.length - shown;
+            if (omitted > 0)
+                lines.push('', overflowNote(omitted));
+            if (suppressed.length) {
+                lines.push('', `<sub>${suppressed.length} finding(s) suppressed as intentional and not counted above.</sub>`);
+            }
+        }
+        lines.push('', footerLine);
         return lines.join('\n');
     }
     // fmt == "text" (default fallback): plain, no markdown/HTML.
     const lines = [
-        `Canary PR Guardian — ${active.length} unaddressed, ` +
-            `${suppressed.length} suppressed`,
+        active.length === 0
+            ? 'Canary PR Guardian — no test-coverage gaps'
+            : `Canary PR Guardian — ${new Set(active.map((f) => f.path)).size} file(s) need test coverage`,
     ];
     for (const finding of ordered) {
+        const unit = finding.unit && finding.unit !== finding.path ? ` → ${finding.unit}` : '';
         const mark = finding.suppressed ? ' (suppressed)' : '';
-        lines.push(`[${finding.severity}] ${finding.path} (${finding.unit}) ` +
-            `[${finding.fidelity}] ${finding.evidence}${mark}`);
+        lines.push(`[${finding.severity}] ${finding.path}${unit} — ${finding.evidence} (${finding.fidelity})${mark}`);
     }
-    let footer = `tier ${tier}`;
+    let footer = `tier ${tier}: deterministic check, no LLM`;
     if (degradedNotice)
         footer += ` - ${degradedNotice}`;
     lines.push(footer);
@@ -716,9 +854,30 @@ export const DEFAULT_SKIP_GLOBS = [
     '**/*.snap',
     // Generated slash-command artifacts and harness state — regenerated from a
     // tracked source (skill.yaml / graph scans), never hand-authored, so a
-    // covering test makes no sense.
+    // covering test makes no sense. `**/.harness/**` also catches harness state
+    // nested under a subproject (e.g. `services/neo/.harness/…`), which the
+    // top-level `.harness/**` misses (#413).
     'agents/commands/**',
     '.harness/**',
+    '**/.harness/**',
+    // Dotfile config/metadata at any depth (.gitignore, .env, .eslintrc,
+    // .neorc*, .dockerignore, .npmrc, …). None carry testable code, so the
+    // heuristic tier's "no test file references this" is a false positive on them
+    // (#413 — observed on `.gitignore` / `.neorc.dev`). Matches only files whose
+    // basename starts with a dot, not source inside a dot-directory.
+    '**/.*',
+    // Build/tooling config files (not authored product logic).
+    '**/*.config.js',
+    '**/*.config.ts',
+    '**/*.config.mjs',
+    '**/*.config.cjs',
+    // Test fixtures / mocks and generated code — noise, not logic under test.
+    '**/fixtures/**',
+    '**/__fixtures__/**',
+    '**/__mocks__/**',
+    '**/testdata/**',
+    '**/generated/**',
+    '**/__generated__/**',
 ];
 /**
  * Parsed `canary.guardian` config block.
@@ -744,6 +903,10 @@ export class GuardianConfig {
     precommit_gate;
     coverage_paths;
     skip_globs;
+    // #413: glob layer suppressing the HEURISTIC tier only (a source path that
+    // still has nothing a naming heuristic can judge). Distinct from
+    // `skip_globs`, which drops a path from the gate entirely at every tier.
+    heuristic_exclude;
     // #320: bound the graph-coverage reverse-BFS. `null` means "gate-derived"
     // (see {@link effectiveGraphDepth} — hard→1 direct edge, soft→unbounded); an
     // explicit int here overrides the gate default on BOTH surfaces.
@@ -758,6 +921,9 @@ export class GuardianConfig {
         this.precommit_gate = init.precommit_gate ?? 'soft';
         this.coverage_paths = init.coverage_paths ?? [];
         this.skip_globs = init.skip_globs ?? [...DEFAULT_SKIP_GLOBS];
+        this.heuristic_exclude = init.heuristic_exclude ?? [
+            ...DEFAULT_HEURISTIC_EXCLUDE_GLOBS,
+        ];
         this.graph_coverage_max_depth = init.graph_coverage_max_depth ?? null;
     }
 }
@@ -927,6 +1093,14 @@ export function loadGuardianConfig(configPath = 'harness.config.json') {
             config.pr_gate = coerceGate(pr['gate'], config.pr_gate, 'pr.gate', warnings);
         }
         config.weak_tests = pyTruthy(pyGet(pr, 'weakTests', config.weak_tests));
+        // #413: same present-vs-absent contract as `skipGlobs` (FIX B) — absent
+        // keeps the built-in default, an explicit list (including `[]`) is honored
+        // verbatim so `heuristicExclude: []` means "no glob layer". The
+        // {@link isSourcePath} extension floor is unaffected either way.
+        const heuristicExclude = pr['heuristicExclude'];
+        if (Array.isArray(heuristicExclude)) {
+            config.heuristic_exclude = heuristicExclude.map((g) => String(g));
+        }
     }
     const precommit = pyGet(block, 'preCommit', {});
     if (isRecord(precommit)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canary-test-cli",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "description": "Canary — AI-powered test automation agent",
   "license": "MIT",
   "repository": {