pi-lens 4.2.0 → 4.3.0

package/rules/tree-sitter-queries/typescript/console-statement.yml

@@ -29,8 +29,8 @@ post_filter: not_in_test_block  # skip test blocks — no-console-in-tests handl
 # trains users to ignore the rule (#965). Application/library code outside
 # these paths still gets flagged.
 ignore_paths:
-  - "scripts/**"
-  - "bin/**"
+  - "**/scripts/**"
+  - "**/bin/**"
   - "**/logger.ts"
   - "**/logger.js"
   - "**/logger.mjs"

package/scripts/install-selftest.mjs

@@ -50,6 +50,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { HOST_PROVIDED_PACKAGES } from "./lib/host-provided-deps.mjs";
 import { collectSkillEntryPaths } from "./lib/skills-predicate.mjs";
+import { resolveWebTreeSitterPackageDir } from "./lib/web-tree-sitter-dir.mjs";
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 const pkgRoot = path.resolve(here, "..");
@@ -220,28 +221,31 @@ try {
 }
 
 // tree-sitter grammars — download-grammars.js postinstall writes them into
-// node_modules/web-tree-sitter/grammars/. Locate that dir via the resolved
-// web-tree-sitter package (matches tree-sitter-client's runtime strategy).
+// node_modules/web-tree-sitter/grammars/. Locate that dir through the SAME
+// shared ladder the extension runtime uses (#3409 round 1, R3418-2): this probe
+// used to resolve the BARE `web-tree-sitter` specifier and walk up, which throws
+// MODULE_NOT_FOUND inside a `bun build --compile` host — so on the very hosts pi
+// ships as, it reported the grammar asset missing while the exported wasm
+// subpath resolved fine. One ladder, one answer, for the client, the pasted
+// install fingerprint and this script.
 let grammarDetail = "tree-sitter-*.wasm missing (postinstall skipped?)";
 let hasCoreGrammar = false;
-try {
-	// web-tree-sitter restricts `exports`, so resolve its main entry and walk
-	// up to the package root (the dir literally named web-tree-sitter), where
-	// download-grammars.js writes grammars/.
-	let dir = path.dirname(require.resolve("web-tree-sitter"));
-	while (
-		path.basename(dir) !== "web-tree-sitter" &&
-		dir !== path.dirname(dir)
-	) {
-		dir = path.dirname(dir);
-	}
-	const grammarDir = path.join(dir, "grammars");
+const webTreeSitterDir = resolveWebTreeSitterPackageDir({
+	resolve: (specifier) => require.resolve(specifier),
+	packageRoot: () => pkgRoot,
+	cwd: () => process.cwd(),
+});
+if (!webTreeSitterDir) {
+	grammarDetail =
+		"web-tree-sitter package dir unresolvable (module resolver, package root and cwd)";
+} else {
+	const grammarDir = path.join(webTreeSitterDir, "grammars");
 	hasCoreGrammar = fs.existsSync(
 		path.join(grammarDir, "tree-sitter-typescript.wasm"),
 	);
-	if (hasCoreGrammar) grammarDetail = grammarDir;
-} catch (err) {
-	grammarDetail = `web-tree-sitter unresolved: ${err?.message || err}`;
+	grammarDetail = hasCoreGrammar
+		? grammarDir
+		: `tree-sitter-*.wasm missing in ${grammarDir} (postinstall skipped?)`;
 }
 record("tree-sitter grammars", "asset", hasCoreGrammar, grammarDetail);
 

package/scripts/lib/web-tree-sitter-dir.mjs

@@ -0,0 +1,123 @@
+/**
+ * Where web-tree-sitter is installed — ONE ladder, for every caller that needs
+ * the answer (#3409).
+ *
+ * Callers: `clients/tree-sitter-client.ts` (the grammar read path and the
+ * lazy-fetch write target), `clients/install-diagnostics.ts` (the pasted
+ * environment fingerprint) and `scripts/install-selftest.mjs` (the installed
+ * host's own diagnostic). Each used to spell its own rungs, and the two that led
+ * with a BARE specifier were unconditionally broken on the host pi ships: inside
+ * a `bun build --compile` binary `require.resolve("web-tree-sitter")` throws
+ * MODULE_NOT_FOUND while `require.resolve("web-tree-sitter/tree-sitter.wasm")` —
+ * an explicit file subpath — still resolves.
+ *
+ * It lives in `scripts/lib/` rather than `clients/` because the installed
+ * selftest is packaged (`files[]`) without `clients/`, and this is the house
+ * pattern for logic a packaged .mjs script and the TypeScript runtime share
+ * (`scripts/lib/skills-predicate.mjs`, `scripts/lib/process-scan.mjs`). It
+ * imports nothing but `node:fs` and `node:path`, so it loads even on the hosts
+ * whose broken dependency graph the selftest exists to report.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** The package this module is about. Also the name its manifest must carry. */
+const WEB_TREE_SITTER = "web-tree-sitter";
+
+/**
+ * The wasm the runtime loads, at the package root — where 0.25.10's `exports`
+ * map puts it (`"./tree-sitter.wasm": "./tree-sitter.wasm"`). If a later release
+ * moves it (#381's 0.26 migration), the two FALLBACK rungs below stop matching
+ * and the resolver rungs, which ask Node for that same subpath, keep working;
+ * this constant is then the one line to update.
+ */
+const RUNTIME_WASM = "tree-sitter.wasm";
+
+/**
+ * True when `dir` IS an installed web-tree-sitter package: its own manifest
+ * names it, and the wasm the runtime loads is in it.
+ *
+ * Round 1 review of #3409 (R3418-1): the constructed rungs used to accept any
+ * directory that merely EXISTED at `<base>/node_modules/web-tree-sitter`, so an
+ * empty or foreign directory of that name became the runtime fetch's write
+ * target and a downloaded grammar would land in an unrelated tree. Existence is
+ * not identity. The manifest name is the identity; the wasm is what makes the
+ * directory the right place to put grammars, since a grammar is only loadable by
+ * the web-tree-sitter runtime sitting next to it (the ABI drift #1564 is about).
+ */
+export function isWebTreeSitterPackageDir(dir) {
+	try {
+		if (!fs.existsSync(path.join(dir, RUNTIME_WASM))) return false;
+		const manifest = JSON.parse(
+			fs.readFileSync(path.join(dir, "package.json"), "utf8"),
+		);
+		return manifest?.name === WEB_TREE_SITTER;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * The package directory owning `resolvedFile`: walk up until a directory passes
+ * the identity check, or the filesystem root is reached. The walk exists because
+ * an `exports` map may point into a subdirectory, so the file's own parent is
+ * not necessarily the package; the identity check is what stops the walk, so a
+ * resolver that answers outside any web-tree-sitter package yields nothing
+ * rather than an unrelated ancestor.
+ */
+function packageDirOf(resolvedFile) {
+	let dir = path.dirname(resolvedFile);
+	for (;;) {
+		if (isWebTreeSitterPackageDir(dir)) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return undefined;
+		dir = parent;
+	}
+}
+
+/**
+ * web-tree-sitter's installed package directory, or undefined.
+ *
+ * Rung order, most authoritative first:
+ *  1. the `tree-sitter.wasm` SUBPATH, which resolves on a compiled host as well
+ *     as a plain one. This is the rung that makes the non-core grammars
+ *     fetchable there at all.
+ *  2. the BARE specifier, for a future web-tree-sitter whose exports map no
+ *     longer carries `./tree-sitter.wasm`.
+ *  3. pi-lens's own package root, for the temp-dir compile layout (#20) where
+ *     the resolver's context is a temp directory but the package root still has
+ *     the right `node_modules`.
+ *  4. the working directory, the pre-#3409 last resort.
+ *
+ * Rungs 1-2 are the resolver's answer and outrank the constructed guesses: the
+ * grammars must come from the SAME package whose wasm the runtime loaded. Every
+ * rung's candidate passes `isWebTreeSitterPackageDir` before it is returned.
+ *
+ * `resolve`, `packageRoot` and `cwd` are injected, never defaulted: the caller's
+ * resolver context and package root are what differ on a compiled host, so they
+ * must not be silently replaced by this module's — and a rung nothing can vary
+ * is a rung no test can drive.
+ */
+export function resolveWebTreeSitterPackageDir(deps) {
+	for (const specifier of [
+		`${WEB_TREE_SITTER}/${RUNTIME_WASM}`,
+		WEB_TREE_SITTER,
+	]) {
+		try {
+			const dir = packageDirOf(deps.resolve(specifier));
+			if (dir) return dir;
+		} catch {
+			/* next rung */
+		}
+	}
+	for (const base of [deps.packageRoot, deps.cwd]) {
+		try {
+			const candidate = path.join(base(), "node_modules", WEB_TREE_SITTER);
+			if (isWebTreeSitterPackageDir(candidate)) return candidate;
+		} catch {
+			/* next rung */
+		}
+	}
+	return undefined;
+}