@0xcraft/powershot 1.1.0 → 1.1.2

package/dist/lang/python-deps.js

@@ -135,11 +135,20 @@ const SKIP_DIRS = new Set([
     'node_modules', '.git', '.venv', 'venv', 'env', '__pycache__', 'dist', 'build',
     '.mypy_cache', '.pytest_cache', '.tox', 'site-packages', 'target', '.next',
 ]);
-export function localModules(root) {
+/**
+ * Importable names near one changed Python file.
+ *
+ * Only direct entries in its ancestor chain and conventional source roots are read.
+ * That bounds work by path depth instead of repository size, while still covering
+ * `src/pkg` beside `tests/test_pkg.py` and namespace packages without __init__.py.
+ */
+export function localModules(root, from = root) {
     const local = new Set();
-    const walk = (dir, depth) => {
-        if (depth > 6 || local.size > 4000)
+    const scanned = new Set();
+    const inspect = (dir) => {
+        if (scanned.has(dir))
             return;
+        scanned.add(dir);
         let entries;
         try {
             entries = readdirSync(dir, { withFileTypes: true });
@@ -147,21 +156,25 @@ export function localModules(root) {
         catch {
             return;
         }
-        const isPackage = entries.some((e) => e.isFile() && e.name === '__init__.py');
         for (const entry of entries) {
             if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name))
                 continue;
             if (entry.isDirectory()) {
-                // a package directory is importable by name; so is a plain source folder
+                // Namespace packages are importable without __init__.py too.
                 local.add(entry.name);
-                walk(join(dir, entry.name), depth + 1);
             }
-            else if (entry.name.endsWith('.py') && (isPackage || depth <= 2)) {
+            else if (entry.isFile() && entry.name.endsWith('.py') && entry.name !== '__init__.py') {
                 local.add(entry.name.slice(0, -3));
             }
         }
     };
-    walk(root, 0);
+    for (let dir = from;; dir = dirname(dir)) {
+        inspect(dir);
+        for (const source of ['src', 'lib', 'python'])
+            inspect(join(dir, source));
+        if (dir === root || dirname(dir) === dir)
+            break;
+    }
     return local;
 }
 export function isPhantom(importName, manifest, local) {

package/dist/manifest.js

@@ -2,6 +2,23 @@ import { createHash } from 'node:crypto';
 import { mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 export const SCHEMA = 'powershot.run/v1';
+/** Human-readable optional depth, kept separate from verdict-blocking notLookedAt. */
+export function unavailableCoverage(record) {
+    const out = [];
+    const files = (record.files ?? []).filter((file) => file.unavailable?.length);
+    if (files.length > 0) {
+        out.push(files.length + ' file(s) without enriched semantic coverage: ' +
+            files.slice(0, 5).map((file) => file.path + ' (' + file.unavailable.join(', ') + ')').join(', ') +
+            (files.length > 5 ? ', …' : ''));
+    }
+    const checks = record.checks?.unavailable ?? [];
+    if (checks.length > 0) {
+        out.push(checks.length + ' enriched check(s) unavailable: ' +
+            checks.slice(0, 8).map((check) => check.check + ' (no ' + check.missing + ')').join(', ') +
+            (checks.length > 8 ? ', …' : ''));
+    }
+    return out;
+}
 /** The single state machine behind manifests, benches, renderers and exit codes. */
 export function completionOf(parts) {
     const waivedUnits = parts.units.filter((unit) => unit.outcome === 'waived').length;
@@ -65,12 +82,20 @@ export class RunManifest {
                 ...file,
                 checks: [...file.checks],
                 missing: file.missing ? [...file.missing] : undefined,
+                unavailable: file.unavailable ? [...file.unavailable] : undefined,
             })),
             units: this.units.map((unit) => ({ ...unit })),
             checks: {
                 ran: [...this.ranChecks],
                 skipped: parts.skippedChecks.map((check) => ({ ...check })),
+                ...((parts.unavailableChecks?.length ?? 0) > 0
+                    ? { unavailable: parts.unavailableChecks.map((check) => ({ ...check })) }
+                    : {}),
             },
+            coverage: parts.files.some((file) => file.missing?.length || file.unavailable?.length) ||
+                parts.skippedChecks.length > 0 || (parts.unavailableChecks?.length ?? 0) > 0
+                ? 'portable'
+                : 'full',
             findings: { ...parts.findings },
             usage: { ...parts.usage },
             state: completion.state,
@@ -118,6 +143,15 @@ export function coverageProblems(m) {
         if (f.disposition !== 'selected' && f.checks.length > 0) {
             problems.push(f.path + ': ' + f.disposition + ' file received checks');
         }
+        if (f.disposition !== 'selected' && f.unavailable?.length) {
+            problems.push(f.path + ': ' + f.disposition + ' file has unavailable coverage');
+        }
+        const missingCaps = new Set(f.missing ?? []);
+        for (const capability of f.unavailable ?? []) {
+            if (missingCaps.has(capability)) {
+                problems.push(f.path + ': capability is both required and unavailable: ' + capability);
+            }
+        }
         const local = new Set();
         for (const check of f.checks) {
             if (local.has(check))
@@ -157,6 +191,21 @@ export function coverageProblems(m) {
         if (ran.has(check.check))
             problems.push('check counted as both ran and skipped: ' + check.check);
     }
+    const unavailable = new Set();
+    for (const check of m.checks.unavailable ?? []) {
+        if (unavailable.has(check.check))
+            problems.push('check counted twice as unavailable: ' + check.check);
+        unavailable.add(check.check);
+        if (skipped.has(check.check))
+            problems.push('check counted as both skipped and unavailable: ' + check.check);
+    }
+    const expectedCoverage = m.files.some((file) => file.missing?.length || file.unavailable?.length) ||
+        m.checks.skipped.length > 0 || (m.checks.unavailable?.length ?? 0) > 0
+        ? 'portable'
+        : 'full';
+    if (m.coverage !== undefined && m.coverage !== expectedCoverage) {
+        problems.push('coverage is ' + m.coverage + ' but accounting says ' + expectedCoverage);
+    }
     // a judged run that reports complete must have reached every unit it selected
     const unreached = m.units.filter((u) => u.outcome === 'failed' || u.outcome === 'waived');
     if (m.state === 'complete' && unreached.length > 0) {

package/dist/plan.js

@@ -67,6 +67,13 @@ export class SelectionPlan {
             row.missing = [...new Set([...(row.missing ?? []), ...missing])];
         }
     }
+    /** Record optional semantic depth that this environment could not provide. */
+    noteUnavailable(path, unavailable) {
+        const row = this.rows.get(path);
+        if (row && row.disposition === 'selected' && unavailable.length > 0) {
+            row.unavailable = [...new Set([...(row.unavailable ?? []), ...unavailable])];
+        }
+    }
     /** Record coverage at the same file granularity used to decide applicability. */
     checked(path, check) {
         const row = this.rows.get(path);

package/dist/report/markdown.js

@@ -1,3 +1,4 @@
+import { unavailableCoverage } from '#app/manifest.js';
 const MARK = { verified: '▣', judged: '▚' };
 /** Untrusted prose encoded as literal CommonMark text. */
 function text(s) {
@@ -63,12 +64,27 @@ export function markdown(findings, run) {
             '',
         ]
         : [];
+    const portable = run?.state === 'complete' && run.coverage === 'portable';
+    const coverage = portable
+        ? [
+            '> [!NOTE]',
+            '> **Portable coverage.** Self-contained oracles ran; enriched semantic depth was unavailable:',
+            ...unavailableCoverage(run).map((reason) => '> - ' + text(reason)),
+            '',
+        ]
+        : [];
     if (findings.length === 0) {
-        return ['## PowerShot', '', ...banner, incomplete ? 'No findings *from what it managed to review*.' : 'No findings.', ''].join('\n');
+        return [
+            '## PowerShot', '', ...banner, ...coverage,
+            incomplete
+                ? 'No findings *from what it managed to review*.'
+                : portable ? 'No findings in portable coverage.' : 'No findings.',
+            '',
+        ].join('\n');
     }
     const verified = findings.filter((f) => f.class === 'verified').length;
     const judged = findings.length - verified;
-    const out = ['## PowerShot', '', ...banner];
+    const out = ['## PowerShot', '', ...banner, ...coverage];
     out.push('**' + verified + ' verified** (deterministic, 0 tokens) · **' + judged + ' judged** (agent)', '');
     for (const [file, list] of group(findings)) {
         out.push('### `' + path(file) + '`', '');

package/dist/report/terminal.js

@@ -106,12 +106,18 @@ export function terminal(findings, opts) {
     out.push(' ' + bold('PowerShot') + dim('  ·  ' + opts.subtitle));
     out.push(rule);
     const incomplete = opts.state !== 'complete';
+    const portable = !incomplete && opts.coverage === 'portable';
     if (findings.length === 0) {
         out.push('', incomplete
             ? ' ' + yellow('!') + '  No findings — but this review is ' + opts.state + ', not a verdict.'
-            : ' ' + steel('✔') + '  No findings.');
+            : ' ' + steel('✔') + (portable ? '  No findings in portable coverage.' : '  No findings.'));
         for (const reason of opts.notLookedAt)
             out.push(dim('    ' + reason));
+        if (portable) {
+            out.push(dim('    Portable coverage: self-contained oracles ran; enriched semantic depth was unavailable.'));
+            for (const reason of opts.unavailableCoverage ?? [])
+                out.push(dim('    ' + reason));
+        }
         out.push('');
         return out.join('\n');
     }
@@ -146,6 +152,11 @@ export function terminal(findings, opts) {
         for (const reason of opts.notLookedAt)
             out.push(dim('   ' + reason));
     }
+    else if (portable) {
+        out.push(' ' + steel('◇ portable coverage') + dim(' · enriched semantic depth was unavailable'));
+        for (const reason of opts.unavailableCoverage ?? [])
+            out.push(dim('   ' + reason));
+    }
     out.push('');
     return out.join('\n');
 }

package/dist/report/viewer.js

@@ -2,12 +2,19 @@ const escape = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/
 export function viewer(findings, meta) {
     const verified = findings.filter((f) => f.class === 'verified').length;
     const incomplete = meta.state !== 'complete';
+    const portable = !incomplete && meta.coverage === 'portable';
     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 coverage = portable
+        ? '<div class="coverage"><strong>Portable coverage.</strong> Self-contained oracles ran; enriched semantic depth was unavailable.' +
+            ((meta.unavailableCoverage?.length ?? 0) > 0
+                ? '<ul>' + meta.unavailableCoverage.map((reason) => '<li>' + escape(reason) + '</li>').join('') + '</ul>'
+                : '') + '</div>'
+        : '';
     const rows = findings
         .map((f) => {
         const frame = f.frame
@@ -70,6 +77,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,6 +91,7 @@ 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}
+  ${coverage}
   <div class="bar">
     <button data-filter="all" aria-pressed="true">all</button>
     <button data-filter="verified" aria-pressed="false">verified</button>
@@ -89,7 +99,7 @@ export function viewer(findings, meta) {
     <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>'
+        ? '<p class="none">' + (incomplete ? 'No findings from what completed.' : portable ? 'No findings in portable coverage.' : 'No findings.') + '</p>'
         : rows}
 </div>
 <script>

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,12 +146,15 @@ 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');
     const g = await buildGround(root, changed, opts.signal);
-    groundDone(g.project.getSourceFiles().length + ' files · ' + g.symbolIndex.size + ' symbols' +
-        (g.typed ? '' : ' · no tsconfig, phantom-api disabled'));
+    groundDone(g.sourceFiles.length + ' files · ' + g.symbolIndex.size + ' symbols' +
+        (g.configFiles.length === 0
+            ? ' · no usable relevant tsconfig, type checks disabled'
+            : ' · ' + g.configFiles.length + ' project(s)' + (g.typed ? '' : ' · type environment incomplete')));
     const wanted = (v) => {
         const id = v.id ?? v.name;
         return opts.checks
@@ -164,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);
@@ -199,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
@@ -209,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);
@@ -225,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);
@@ -346,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,