@0xcraft/powershot 1.0.1 → 1.1.1

package/dist/ground.js

@@ -1,33 +1,174 @@
 import { Project, SyntaxKind } from 'ts-morph';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { decode } from './text.js';
-import { join, dirname } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { packFor, parse } from './lang/packs.js';
 import { insideRepo, isSymlink, repoPath } from './fspolicy.js';
 const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+const TS_CONFIG = /^tsconfig(?:\..+)?\.json$/i;
+const MISSING_TYPE_PREFIXES = [
+    'Cannot find global type',
+    'Cannot find global value',
+    'Cannot find module',
+    'Cannot find name',
+    'Cannot find type definition file',
+    'Could not find a declaration file for module',
+];
+/**
+ * A property diagnostic is only exact when the file's ambient types resolved.
+ * Missing modules, globals, or declaration files can remove interface
+ * augmentations and manufacture downstream errors such as `ImportMeta.url`.
+ */
+function hasTypeEnvironmentGap(sf) {
+    return sf.getPreEmitDiagnostics().some((diagnostic) => {
+        const message = diagnostic.getMessageText();
+        const head = typeof message === 'string' ? message : message.getMessageText();
+        return MISSING_TYPE_PREFIXES.some((prefix) => head.startsWith(prefix)) || /^File .+ not found/.test(head);
+    });
+}
 export function normalizeName(n) {
     return n.toLowerCase().replace(/[^a-z0-9]/g, '');
 }
-/**
- * Walks up, but never past `stop`.
- *
- * A tsconfig above the repository is somebody else's, and letting one configure the
- * program that reviews this repository lets a parent directory decide what is
- * type-checked and where paths resolve to.
- */
-function findUp(from, name, stop = from) {
-    let dir = from;
-    for (;;) {
-        const p = join(dir, name);
-        if (existsSync(p))
-            return p;
-        if (dir === stop)
-            return undefined;
+/** A lexical repository containment check for paths that have already been resolved. */
+function isWithin(root, path) {
+    const rel = relative(root, path);
+    return rel === '' || (rel !== '..' && !rel.startsWith('..' + sep) && !isAbsolute(rel));
+}
+/** Directories from a changed file up to the repository root, nearest first. */
+function ancestorDirectories(root, absPath) {
+    const out = [];
+    let dir = dirname(absPath);
+    while (isWithin(root, dir)) {
+        out.push(dir);
+        if (dir === root)
+            break;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return out;
+}
+/** Only inspect the directory chain of changed files; never crawl the monorepo. */
+function configsInDirectory(dir, cache) {
+    const known = cache.get(dir);
+    if (known)
+        return known;
+    let configs = [];
+    try {
+        configs = readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && TS_CONFIG.test(entry.name))
+            .map((entry) => join(dir, entry.name))
+            .sort();
+    }
+    catch {
+        // An unreadable ancestor contributes no project; the file remains syntax-only.
+    }
+    cache.set(dir, configs);
+    return configs;
+}
+function configuredProject(root, configPath) {
+    try {
+        const project = new Project({ tsConfigFilePath: configPath });
+        const owned = new Set();
+        const sourceAncestors = new Set();
+        for (const sf of project.getSourceFiles()) {
+            const abs = resolve(sf.getFilePath());
+            const safe = insideRepo(root, abs);
+            if (!safe || repoPath(root, abs).split('/').includes('node_modules'))
+                continue;
+            owned.add(repoPath(root, abs));
+            let dir = dirname(abs);
+            while (isWithin(root, dir)) {
+                sourceAncestors.add(dir);
+                if (dir === root)
+                    break;
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break;
+                dir = parent;
+            }
+        }
+        return { configPath, project, owned, sourceAncestors, sourceCount: owned.size };
+    }
+    catch {
+        // A broken candidate beside a usable leaf config must not take down the review.
+        return undefined;
+    }
+}
+function directoryDepth(root, dir) {
+    const rel = repoPath(root, dir);
+    return rel === '' ? 0 : rel.split('/').length;
+}
+function sourceAffinity(root, candidate, absPath) {
+    let dir = dirname(absPath);
+    while (isWithin(root, dir)) {
+        if (candidate.sourceAncestors.has(dir))
+            return directoryDepth(root, dir);
+        if (dir === root)
+            break;
         const parent = dirname(dir);
         if (parent === dir)
-            return undefined;
+            break;
         dir = parent;
     }
+    return -1;
+}
+function nameAffinity(root, configPath, absPath) {
+    const base = basename(configPath);
+    const name = base.slice('tsconfig'.length, -'.json'.length).replace(/^\./, '');
+    if (name === '')
+        return 0;
+    const tokens = new Set(repoPath(root, absPath).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+    return name
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean)
+        .filter((token) => tokens.has(token)).length;
+}
+/** Prefer the leaf project whose existing sources live closest to this file. */
+function bestProject(root, candidates, absPath) {
+    return [...candidates].sort((a, b) => sourceAffinity(root, b, absPath) - sourceAffinity(root, a, absPath) ||
+        nameAffinity(root, b.configPath, absPath) - nameAffinity(root, a.configPath, absPath) ||
+        a.sourceCount - b.sourceCount ||
+        a.configPath.localeCompare(b.configPath))[0];
+}
+function looksLikeTest(path) {
+    return /(?:^|[/\\])(?:__tests__|tests?)(?:[/\\]|$)/i.test(path) || /\.(?:test|spec)\.[^.]+$/i.test(path);
+}
+/**
+ * Resolve one changed file at the nearest useful project boundary.
+ *
+ * Solution configs (`files: []`) do not claim a type environment. If a sibling leaf
+ * config owns the file it wins; if every leaf excludes the file (common for tests),
+ * the closest suitable non-empty leaf supplies compiler options and references.
+ * Selecting that local leaf avoids opening a repository-wide parent.
+ */
+function projectForFile(root, absPath, directoryCache, projectCache) {
+    const rel = repoPath(root, absPath);
+    for (const dir of ancestorDirectories(root, absPath)) {
+        const configPaths = [...configsInDirectory(dir, directoryCache)].sort((a, b) => nameAffinity(root, b, absPath) - nameAffinity(root, a, absPath) || a.localeCompare(b));
+        const projects = [];
+        for (const configPath of configPaths) {
+            if (!projectCache.has(configPath)) {
+                projectCache.set(configPath, configuredProject(root, configPath));
+            }
+            const project = projectCache.get(configPath);
+            if (!project)
+                continue;
+            // Config names such as `test`, `app`, and `node` are ranked against the file
+            // path, so the first owner is the most specific without opening every sibling.
+            if (project.owned.has(rel))
+                return project;
+            projects.push(project);
+        }
+        const boundaryDepth = directoryDepth(root, dir);
+        const leaves = projects.filter((project) => project.sourceCount > 0 &&
+            (sourceAffinity(root, project, absPath) > boundaryDepth || looksLikeTest(absPath)));
+        if (leaves.length > 0)
+            return bestProject(root, leaves, absPath);
+    }
+    return undefined;
 }
 function depsIn(pkgPath) {
     const deps = new Set();
@@ -70,36 +211,45 @@ function makeDepsFor(root) {
     };
 }
 /**
- * Build the oracle once per run: a type-checked project over the working tree,
- * a syntax-only project holding the base-ref versions, and a symbol index.
+ * Build the oracle once per run: focused type-checked projects for the changed
+ * packages, a syntax-only project for unconfigured changes and the base-ref trees,
+ * and one deduplicated symbol index over the relevant project closures.
  */
 export async function buildGround(root, changed, signal) {
-    const tsConfigFilePath = findUp(root, 'tsconfig.json');
-    const typed = Boolean(tsConfigFilePath);
-    const project = typed
-        ? new Project({ tsConfigFilePath })
-        : new Project({ compilerOptions: { allowJs: true, checkJs: false } });
-    if (!typed)
-        project.addSourceFilesAtPaths([`${root}/**/*.{ts,tsx,js,jsx,mts,cts}`, `!${root}/**/node_modules/**`]);
-    // What the tsconfig itself owns. A file added past this point is present for
-    // reading, but the checker has no program for it — asking one for diagnostics
-    // throws from inside TypeScript, which took the whole review down with it.
-    const owned = new Set(project.getSourceFiles().map((f) => repoPath(root, String(f.getFilePath()))));
-    // A changed file may be new, or excluded from tsconfig — make sure it is present.
-    // `readable` is the gate for every file that becomes reviewable: the glob above
-    // follows symlinks, so passing this on the way in is not enough on its own.
+    root = resolve(root);
+    const directoryCache = new Map();
+    const projectCache = new Map();
+    const selectedProjects = new Set();
+    const assigned = new Map();
+    const syntaxProject = new Project({ compilerOptions: { allowJs: true, checkJs: false } });
+    // `readable` is the gate for every file that becomes reviewable. A tsconfig glob
+    // can follow symlinks, so selected project closures are checked again below too.
     const readable = (path) => {
         const abs = insideRepo(root, path);
         return abs && !isSymlink(abs) ? abs : undefined;
     };
     for (const c of changed) {
+        if (signal?.aborted)
+            break;
         if (!CODE_EXT.test(c.path))
             continue;
         const abs = readable(c.path);
-        if (!abs)
+        if (!abs || !existsSync(abs))
             continue;
-        if (!project.getSourceFile(abs) && existsSync(abs))
-            project.addSourceFileAtPath(abs);
+        const configured = projectForFile(root, abs, directoryCache, projectCache);
+        if (configured) {
+            selectedProjects.add(configured);
+            assigned.set(c.path, configured);
+            // Tests and tooling files are often excluded from the production build config.
+            // Adding one explicitly keeps the leaf project's compiler options and imports.
+            if (!configured.project.getSourceFile(abs))
+                configured.project.addSourceFileAtPath(abs);
+        }
+        else if (!syntaxProject.getSourceFile(abs)) {
+            // No recursive glob: a configless million-file repository still loads only the
+            // files in the review.
+            syntaxProject.addSourceFileAtPath(abs);
+        }
     }
     const beforeProject = new Project({ useInMemoryFileSystem: true });
     const files = [];
@@ -109,79 +259,78 @@ export async function buildGround(root, changed, signal) {
         const abs = readable(c.path);
         if (!abs)
             continue;
-        const sf = project.getSourceFile(abs);
+        const configured = assigned.get(c.path);
+        const sf = configured?.project.getSourceFile(abs) ?? syntaxProject.getSourceFile(abs);
         if (!sf)
             continue;
         const before = c.before === undefined ? undefined : beforeProject.createSourceFile(`/before/${c.path}`, c.before, { overwrite: true });
-        files.push({ sf, changed: c, before, typed: typed && owned.has(repoPath(root, c.path)) });
+        files.push({
+            sf,
+            changed: c,
+            before,
+            // A bound program with unresolved ambient types is not an exact type oracle.
+            // Keep the file reviewable, but make type-dependent checks explicitly partial.
+            typed: configured !== undefined && !hasTypeEnvironmentGap(sf),
+        });
     }
+    const projects = [...selectedProjects].map((selected) => selected.project);
+    if (syntaxProject.getSourceFiles().length > 0)
+        projects.push(syntaxProject);
+    const sourceFiles = uniqueSourceFiles(root, files.map((file) => file.sf), projects);
+    const configFiles = [...selectedProjects]
+        .map((selected) => repoPath(root, selected.configPath))
+        .sort();
+    const typed = files.some((file) => file.typed);
+    const depsFor = makeDepsFor(root);
     return {
         root,
-        project,
+        sourceFiles,
+        configFiles,
         beforeProject,
         changed,
         files,
-        symbolIndex: buildSymbolIndex(project, root),
-        deps: makeDepsFor(root)(join(root, 'x.ts')),
-        depsFor: makeDepsFor(root),
+        symbolIndex: buildSymbolIndex(sourceFiles, root),
+        deps: depsFor(join(root, 'x.ts')),
+        depsFor,
         typed,
-        internalPrefixes: pathAliasPrefixes(project, root),
+        internalPrefixes: pathAliasPrefixes(projects),
         foreign: await parseForeign(root, changed, signal),
         envManifest: readEnvManifest(root),
     };
 }
+/** Prefer changed-file SourceFiles, then add each relevant project source once. */
+function uniqueSourceFiles(root, preferred, projects) {
+    const byPath = new Map();
+    const add = (sf) => {
+        const abs = resolve(sf.getFilePath());
+        if (!insideRepo(root, abs))
+            return;
+        const rel = repoPath(root, abs);
+        if (rel.split('/').includes('node_modules') || byPath.has(rel))
+            return;
+        byPath.set(rel, sf);
+    };
+    for (const sf of preferred)
+        add(sf);
+    for (const project of projects)
+        for (const sf of project.getSourceFiles())
+            add(sf);
+    return [...byPath.values()];
+}
 /**
  * Prefixes that `compilerOptions.paths` maps back into the repo — `@/*` and friends.
  * They look like package names but resolve to local files, so treating them as
  * dependencies would be wrong.
  */
-function pathAliasPrefixes(project, root) {
+function pathAliasPrefixes(projects) {
     const prefixes = new Set();
-    for (const pattern of Object.keys(project.getCompilerOptions().paths ?? {})) {
-        prefixes.add(pattern.replace(/\*$/, ''));
-    }
-    // a workspace declares its aliases in each package's tsconfig, and the root config
-    // often only `extends` a shared base — so the root's paths are not the whole story
-    for (const file of tsconfigsIn(root)) {
-        try {
-            const raw = readFileSync(file, 'utf8').replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|\s)\/\/.*$/gm, '$1');
-            const parsed = JSON.parse(raw.replace(/,(\s*[}\]])/g, '$1'));
-            for (const pattern of Object.keys(parsed?.compilerOptions?.paths ?? {})) {
-                prefixes.add(String(pattern).replace(/\*$/, ''));
-            }
-        }
-        catch {
-            // an unreadable or non-standard tsconfig simply contributes no aliases
+    for (const project of projects) {
+        for (const pattern of Object.keys(project.getCompilerOptions().paths ?? {})) {
+            prefixes.add(pattern.replace(/\*$/, ''));
         }
     }
     return [...prefixes];
 }
-/** every tsconfig in the repo, capped so a huge monorepo cannot stall the run */
-function tsconfigsIn(root) {
-    const out = [];
-    const walk = (dir, depth) => {
-        if (depth > 4 || out.length > 60)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const e of entries) {
-            if (e.name === 'node_modules' || e.name.startsWith('.'))
-                continue;
-            const full = join(dir, e.name);
-            if (e.isDirectory())
-                walk(full, depth + 1);
-            else if (e.name === 'tsconfig.json')
-                out.push(full);
-        }
-    };
-    walk(root, 0);
-    return out;
-}
 /**
  * Changed files the TypeScript project cannot hold. Nine of the checks need only a
  * parse tree, so a Python or Go file is reviewable the moment its grammar loads —
@@ -235,9 +384,9 @@ async function parseForeign(root, changed, signal) {
     }
     return out;
 }
-function buildSymbolIndex(project, root) {
+function buildSymbolIndex(sourceFiles, root) {
     const index = new Map();
-    for (const sf of project.getSourceFiles()) {
+    for (const sf of sourceFiles) {
         const path = String(sf.getFilePath());
         // the project glob follows symlinked directories, so what it loaded is not
         // proof of where the file is

package/dist/judges/tools.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { relPath } from '#app/ground.js';
-import { insideRepo } from '#app/fspolicy.js';
+import { insideRepo, repoPath } from '#app/fspolicy.js';
 const MAX_BYTES = 60_000;
 const MAX_MATCHES = 40;
 export const TOOLS = [
@@ -58,7 +58,7 @@ function readFile(g, input) {
     const abs = insideRepo(g.root, path);
     if (!abs)
         return 'Refused: that path is outside the repository or is not readable for review.';
-    const inProject = g.project.getSourceFile(abs);
+    const inProject = g.sourceFiles.find((file) => relPath(file, g.root) === repoPath(g.root, abs));
     const text = inProject ? inProject.getFullText() : readFileSync(abs, 'utf8');
     const lines = text.split('\n');
     const start = Math.max(1, Number(input.start ?? 1));
@@ -79,7 +79,7 @@ function grep(g, input) {
     }
     const filter = input.path_contains === undefined ? undefined : String(input.path_contains);
     const hits = [];
-    for (const sf of g.project.getSourceFiles()) {
+    for (const sf of g.sourceFiles) {
         const abs = sf.getFilePath();
         // the project glob can pull in a file through a symlinked directory, so the
         // boundary is re-checked here rather than trusted from how the file got loaded
@@ -98,13 +98,13 @@ function grep(g, input) {
                 return hits.join('\n') + '\n… more matches not shown';
         }
     }
-    return hits.length > 0 ? hits.join('\n') : 'No matches.';
+    return hits.length > 0 ? hits.join('\n') : 'No matches in the relevant project files.';
 }
 function references(g, input) {
     const symbol = String(input.symbol ?? '');
     if (!symbol)
         return 'No symbol given.';
-    for (const sf of g.project.getSourceFiles()) {
+    for (const sf of g.sourceFiles) {
         const path = String(sf.getFilePath());
         if (path.includes('/node_modules/') || !insideRepo(g.root, path))
             continue;
@@ -117,9 +117,9 @@ function references(g, input) {
             .map((n) => relPath(n.getSourceFile(), g.root) + ':' + n.getStartLineNumber())
             .filter((r) => !r.includes('node_modules'));
         return refs.length === 0
-            ? symbol + ' is declared in ' + relPath(sf, g.root) + ' and referenced nowhere.'
+            ? symbol + ' is declared in ' + relPath(sf, g.root) + ' and referenced nowhere in its project.'
             : symbol + ' declared in ' + relPath(sf, g.root) + ', referenced at:\n' + [...new Set(refs)].slice(0, MAX_MATCHES).join('\n');
     }
-    return 'No declaration named ' + symbol + ' found in the project.';
+    return 'No declaration named ' + symbol + ' found in the relevant projects.';
 }
 //# sourceMappingURL=tools.js.map

package/dist/package-smoke.js

@@ -64,6 +64,8 @@ try {
             throw new Error('architecture guide is missing');
         if (!existsSync(join(installed, 'docs', 'ci.md')))
             throw new Error('CI guide is missing');
+        if (!existsSync(join(installed, 'dist', 'github', 'inline-comments.js')))
+            throw new Error('inline review runtime is missing');
         if (!existsSync(join(installed, 'examples', 'github-actions', 'cli.yml')))
             throw new Error('CI example is missing');
         if (!existsSync(join(installed, 'examples', 'gitlab', '.gitlab-ci.yml')))

package/dist/review.js

@@ -146,8 +146,10 @@ export async function review(opts) {
     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