@0xcraft/powershot 1.1.1 → 1.1.3

package/dist/report/summary.js

@@ -0,0 +1,103 @@
+function plural(count, singular, pluralForm = singular + 's') {
+    return count + ' ' + (count === 1 ? singular : pluralForm);
+}
+function capabilityName(capability) {
+    return {
+        types: 'type information',
+        references: 'a reference graph',
+        'python-types': 'Python type information',
+        base: 'a base revision',
+        syntax: 'a syntax tree',
+    }[capability] ?? capability;
+}
+function naturalList(values, conjunction = 'and') {
+    if (values.length < 2)
+        return values[0] ?? '';
+    if (values.length === 2)
+        return values[0] + ' ' + conjunction + ' ' + values[1];
+    return values.slice(0, -1).join(', ') + ', ' + conjunction + ' ' + values.at(-1);
+}
+function scopeDetails(record) {
+    const details = [];
+    const selected = (record.files ?? []).filter((file) => file.disposition === 'selected');
+    const unavailableGroups = new Map();
+    for (const file of selected) {
+        if (!file.unavailable?.length)
+            continue;
+        const order = ['types', 'references', 'python-types', 'base', 'syntax'];
+        const capabilities = [...new Set(file.unavailable)].sort((left, right) => {
+            const leftRank = order.indexOf(left);
+            const rightRank = order.indexOf(right);
+            return (leftRank === -1 ? order.length : leftRank) - (rightRank === -1 ? order.length : rightRank) ||
+                left.localeCompare(right);
+        });
+        const key = capabilities.join('\0');
+        const group = unavailableGroups.get(key) ?? { capabilities, count: 0 };
+        group.count++;
+        unavailableGroups.set(key, group);
+    }
+    for (const group of unavailableGroups.values()) {
+        const capabilities = naturalList(group.capabilities.map(capabilityName));
+        details.push(plural(group.count, 'reviewed file') + ' lacked ' + capabilities + '.');
+    }
+    const unavailableChecks = record.checks?.unavailable ?? [];
+    if (unavailableChecks.length > 0) {
+        const shown = unavailableChecks.slice(0, 8).map((check) => check.check);
+        const requirements = [...new Set(unavailableChecks.flatMap((check) => check.missing.split(/,\s*/)))]
+            .map(capabilityName);
+        details.push(plural(unavailableChecks.length, 'check') + ' requiring ' + naturalList(requirements, 'or') +
+            ' did not run: ' + shown.join(', ') +
+            (unavailableChecks.length > shown.length ? ', and ' + (unavailableChecks.length - shown.length) + ' more' : '') + '.');
+    }
+    const waived = new Map();
+    for (const file of record.files ?? []) {
+        if (file.disposition !== 'waived')
+            continue;
+        const reason = file.reason ?? 'unspecified reason';
+        waived.set(reason, (waived.get(reason) ?? 0) + 1);
+    }
+    for (const [reason, count] of waived) {
+        details.push(plural(count, 'changed file') + ' not reviewed: ' + reason + '.');
+    }
+    return details;
+}
+export function summarizeRun(record) {
+    const hasFiles = record.files !== undefined;
+    const hasChecks = record.checks?.ran !== undefined;
+    return {
+        state: record.state,
+        notLookedAt: [...record.notLookedAt],
+        coverage: record.coverage,
+        verifyOnly: record.engine?.verifyOnly,
+        minSeverity: record.engine?.minSeverity,
+        filesReviewed: hasFiles
+            ? record.files.filter((file) => file.disposition === 'selected').length
+            : undefined,
+        deterministicChecks: hasChecks ? new Set(record.checks.ran).size : undefined,
+        scopeDetails: scopeDetails(record),
+    };
+}
+export function noFindingsLabel(summary) {
+    const threshold = summary.minSeverity === undefined || summary.minSeverity === 'info'
+        ? ''
+        : summary.minSeverity === 'critical'
+            ? 'critical '
+            : summary.minSeverity + '-or-higher ';
+    const origin = summary.verifyOnly === true ? 'deterministic ' : '';
+    return 'No ' + threshold + origin + 'findings';
+}
+export function scopeLine(summary) {
+    const parts = [];
+    if (summary.filesReviewed !== undefined)
+        parts.push(plural(summary.filesReviewed, 'file') + ' reviewed');
+    if (summary.deterministicChecks !== undefined) {
+        parts.push(plural(summary.deterministicChecks, 'deterministic check'));
+    }
+    if (summary.coverage !== undefined)
+        parts.push(summary.coverage + ' coverage');
+    return parts.length > 0 ? parts.join(' · ') : undefined;
+}
+export function modeNote(summary, verifyOnly = 'verify-only') {
+    return summary.verifyOnly === true ? 'Model review was disabled (' + verifyOnly + ').' : undefined;
+}
+//# sourceMappingURL=summary.js.map

package/dist/report/terminal.js

@@ -1,5 +1,6 @@
 import { bold, brightRed, dim, gray, red, steel, yellow } from './ansi.js';
 import { highlight, isJsx } from './highlight.js';
+import { modeNote, noFindingsLabel, scopeLine } from './summary.js';
 const SEVERITY_COLOR = {
     critical: brightRed,
     high: red,
@@ -106,12 +107,23 @@ export function terminal(findings, opts) {
     out.push(' ' + bold('PowerShot') + dim('  ·  ' + opts.subtitle));
     out.push(rule);
     const incomplete = opts.state !== 'complete';
+    const scope = scopeLine(opts);
+    const mode = modeNote(opts);
     if (findings.length === 0) {
         out.push('', incomplete
             ? ' ' + yellow('!') + '  No findings — but this review is ' + opts.state + ', not a verdict.'
-            : ' ' + steel('✔') + '  No findings.');
+            : ' ' + steel('✔') + '  ' + noFindingsLabel(opts) + '.');
         for (const reason of opts.notLookedAt)
             out.push(dim('    ' + reason));
+        if (scope)
+            out.push(dim('    ' + scope));
+        if (mode)
+            out.push(dim('    ' + mode));
+        if ((opts.scopeDetails?.length ?? 0) > 0) {
+            out.push(dim('    ' + (opts.coverage === 'portable' ? 'Coverage details:' : 'Review scope:')));
+            for (const detail of opts.scopeDetails)
+                out.push(dim('      - ' + detail));
+        }
         out.push('');
         return out.join('\n');
     }
@@ -146,6 +158,12 @@ export function terminal(findings, opts) {
         for (const reason of opts.notLookedAt)
             out.push(dim('   ' + reason));
     }
+    if (scope)
+        out.push(' ' + steel('◇ ') + dim(scope));
+    if (mode)
+        out.push(dim('   ' + mode));
+    for (const detail of opts.scopeDetails ?? [])
+        out.push(dim('   ' + detail));
     out.push('');
     return out.join('\n');
 }

package/dist/report/viewer.js

@@ -1,13 +1,30 @@
+import { modeNote, noFindingsLabel, scopeLine } from './summary.js';
 const escape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 export function viewer(findings, meta) {
     const verified = findings.filter((f) => f.class === 'verified').length;
     const incomplete = meta.state !== 'complete';
+    const scope = scopeLine(meta);
+    const mode = modeNote(meta);
     const warning = incomplete
         ? '<div class="warning"><strong>This review is ' + escape(meta.state) + ' — not a verdict.</strong>' +
             (meta.notLookedAt.length > 0
                 ? '<ul>' + meta.notLookedAt.map((reason) => '<li>' + escape(reason) + '</li>').join('') + '</ul>'
                 : '') + '</div>'
         : '';
+    const context = scope || mode || (meta.scopeDetails?.length ?? 0) > 0
+        ? '<div class="coverage">' +
+            (scope ? '<strong>' + escape(scope) + '</strong>' : '') +
+            (mode ? '<p>' + escape(mode) + '</p>' : '') +
+            ((meta.scopeDetails?.length ?? 0) > 0
+                ? '<details><summary>' + (meta.coverage === 'portable' ? 'Coverage details' : 'Review scope') + '</summary><ul>' +
+                    meta.scopeDetails.map((detail) => '<li>' + escape(detail) + '</li>').join('') +
+                    '</ul></details>'
+                : '') + '</div>'
+        : '';
+    const verdict = findings.length === 0
+        ? '<p class="none">' +
+            (incomplete ? 'No findings from what completed.' : escape(noFindingsLabel(meta)) + '.') + '</p>'
+        : '';
     const rows = findings
         .map((f) => {
         const frame = f.frame
@@ -70,6 +87,8 @@ export function viewer(findings, meta) {
   .none { color:var(--muted); }
   .warning { border:1px solid var(--amber); border-radius:6px; padding:10px 14px; margin:0 0 18px; }
   .warning ul { margin:6px 0 0; }
+  .coverage { border:1px solid var(--steel); border-radius:6px; padding:10px 14px; margin:0 0 18px; }
+  .coverage ul { margin:6px 0 0; }
   .f.put-away { opacity:.4; }
   .f.put-away .title { text-decoration:line-through; }
   .act { margin-left:8px; }
@@ -82,15 +101,15 @@ export function viewer(findings, meta) {
   <p class="meta">${escape(meta.target)} · ${escape(meta.started.slice(0, 19).replace('T', ' '))} · session ${escape(meta.id)}<br>
     ${findings.length} finding(s) — ${verified} verified, ${findings.length - verified} judged</p>
   ${warning}
+  ${verdict}
+  ${context}
   <div class="bar">
     <button data-filter="all" aria-pressed="true">all</button>
     <button data-filter="verified" aria-pressed="false">verified</button>
     <button data-filter="judged" aria-pressed="false">judged</button>
     <button id="show-away" aria-pressed="false">show put away</button>
   </div>
-  ${findings.length === 0
-        ? '<p class="none">' + (incomplete ? 'No findings from what completed.' : 'No findings.') + '</p>'
-        : rows}
+  ${findings.length === 0 ? '' : rows}
 </div>
 <script>
   // Putting a finding away is per-reader and per-browser on purpose: this page is a

package/dist/review.js

@@ -2,7 +2,6 @@ import { buildGround } from './ground.js';
 import { baseRefOf, collectChanges, statedIntent } from './git.js';
 import { bundle, bundleName, reviewables, uncovered } from './bundle.js';
 import { attachFrames, positionable } from './position.js';
-import { skippedLanguages } from './lang/packs.js';
 import { JudgeCache } from './cache.js';
 import { Dismissals, rememberReport } from './dismissed.js';
 import { renderChanges } from './judges/judge.js';
@@ -16,7 +15,6 @@ import { Budget } from './budget.js';
 import { packFor } from './lang/packs.js';
 import { SEVERITIES } from './types.js';
 import { stripControl, stripPath } from './text.js';
-const packOf = (path) => packFor(path)?.name ?? 'other';
 export function atLeast(severity, min) {
     return SEVERITIES.indexOf(severity) >= SEVERITIES.indexOf(min);
 }
@@ -33,20 +31,24 @@ export function titleOverlap(a, b) {
             shared++;
     return shared / Math.min(left.size, right.size);
 }
+const PORTABLE_OPTIONAL = new Set(['types', 'references', 'python-types']);
 /**
  * Files this verifier can actually answer for, with unavailable oracles kept per
- * file. `base` is applicability rather than a missing capability: a before/after
- * check has no question to ask about a newly created file.
+ * file. A before/after check has no question to ask about a newly created file;
+ * when an existing file has a base snapshot that cannot be parsed, `base` is a real
+ * missing capability and remains verdict-blocking in every coverage profile.
  */
 function verifierTargets(v, g, have) {
     if (v.domain === 'typescript') {
         return g.files
-            .filter((file) => !v.needs.includes('base') || file.before !== undefined)
+            .filter((file) => !v.needs.includes('base') || file.changed.before !== undefined)
             .map((file) => ({
             kind: 'typescript',
             path: file.changed.path,
             file,
             missing: v.needs.filter((need) => {
+                if (need === 'base')
+                    return file.before === undefined;
                 if (need === 'types' || need === 'references')
                     return !file.typed;
                 if (need === 'python-types')
@@ -59,12 +61,14 @@ function verifierTargets(v, g, have) {
         return g.foreign
             .filter((file) => v.domain !== 'python' || file.pack.name === 'python')
             .filter((file) => !v.supports || v.supports(file))
-            .filter((file) => !v.needs.includes('base') || file.beforeTree !== undefined)
+            .filter((file) => !v.needs.includes('base') || file.changed.before !== undefined)
             .map((file) => ({
             kind: 'foreign',
             path: file.path,
             file,
             missing: v.needs.filter((need) => {
+                if (need === 'base')
+                    return file.beforeTree === undefined;
                 if (need === 'python-types')
                     return file.pack.name !== 'python' || !have.has('python-types');
                 if (need === 'types' || need === 'references')
@@ -142,6 +146,7 @@ export async function review(opts) {
         return { findings: [], stats: { files: 0, verified: 0, judged: 0, dismissed: 0 }, failures, plan };
     }
     const skipped = new Map();
+    const unavailable = new Map();
     const budget = opts.budget ?? new Budget();
     const manifest = opts.manifest;
     const groundDone = stage('ground');
@@ -166,27 +171,33 @@ export async function review(opts) {
             targets.set(verifier, files);
     }
     const selectedVerifiers = [...targets.keys()];
+    // Naming a check explicitly is a request for that oracle, even under the portable
+    // default. Strict policy makes the same promise for every configured verifier.
+    const requireEnrichedOracles = config.coverage === 'strict' || opts.checks !== undefined;
     // a file the change touched that no parser produced a tree for was not reviewed,
     // whatever the summary says about the ones that were
     const grounded = new Set([...g.files.map((f) => f.changed.path), ...g.foreign.map((f) => f.path)]);
     for (const c of changed) {
-        if (!grounded.has(c.path))
+        if (grounded.has(c.path))
+            continue;
+        if (packFor(c.path))
+            plan.fail(c.path, 'declared language parser unavailable');
+        else
             plan.waive(c.path, 'no parser for this language');
     }
     // Capabilities belong to files, not runs. A typed file beside one excluded from
     // tsconfig must not make the latter look checked, and an old Ruby file must not
     // make a new Python file eligible for a before/after oracle.
     for (const files of targets.values()) {
-        for (const file of files)
-            plan.limit(file.path, file.missing);
-    }
-    if (skippedLanguages.length > 0) {
-        for (const c of changed) {
-            if (!grounded.has(c.path) && skippedLanguages.includes(packOf(c.path))) {
-                plan.fail(c.path, 'grammar budget reached');
-            }
+        for (const file of files) {
+            const required = file.missing.filter((capability) => !PORTABLE_OPTIONAL.has(capability));
+            const enriched = file.missing.filter((capability) => PORTABLE_OPTIONAL.has(capability));
+            plan.limit(file.path, required);
+            if (requireEnrichedOracles)
+                plan.limit(file.path, enriched);
+            else
+                plan.noteUnavailable(file.path, enriched);
         }
-        failures.push('not reviewed, grammar budget reached: ' + skippedLanguages.join(', '));
     }
     for (const line of plan.summary())
         say('selection ' + line);
@@ -201,8 +212,14 @@ export async function review(opts) {
         const files = targets.get(v);
         const eligible = files.filter((file) => file.missing.length === 0);
         const missing = [...new Set(files.flatMap((file) => file.missing))];
+        const check = v.id ?? v.name;
+        const onlyEnrichedMissing = missing.every((capability) => PORTABLE_OPTIONAL.has(capability));
+        if (missing.length > 0 && !requireEnrichedOracles && onlyEnrichedMissing) {
+            unavailable.set(check, missing.join(', '));
+        }
         if (missing.length > 0 && eligible.length === 0) {
-            skipped.set(v.id ?? v.name, missing.join(', '));
+            if (requireEnrichedOracles || !onlyEnrichedMissing)
+                skipped.set(check, missing.join(', '));
             continue;
         }
         // a scan spends most of its time here, so Ctrl-C has to reach this half
@@ -211,7 +228,6 @@ export async function review(opts) {
             break;
         }
         ran++;
-        const check = v.id ?? v.name;
         manifest?.ran(check);
         for (const file of eligible)
             plan.checked(file.path, check);
@@ -227,6 +243,10 @@ export async function review(opts) {
         const names = [...skipped].map(([n, why]) => n + ' (no ' + why + ')');
         say('skipped   ' + names.join(', '));
     }
+    if (unavailable.size > 0) {
+        const names = [...unavailable].map(([n, why]) => n + ' (no ' + why + ')');
+        say('coverage  portable · enriched checks unavailable: ' + names.join(', '));
+    }
     // --checks overrides the config rather than filtering it
     const isGated = range.from !== undefined || range.commit !== undefined;
     const judgeCache = opts.cache === false || verifyOnly ? undefined : JudgeCache.open(repo, isGated);
@@ -348,6 +368,7 @@ export async function review(opts) {
         failures,
         plan,
         skippedChecks: [...skipped].map(([check, missing]) => ({ check, missing })),
+        unavailableChecks: [...unavailable].map(([check, missing]) => ({ check, missing })),
         usage: budget.finish(),
         budgetStop,
         cancelled: opts.signal?.aborted ?? false,