pi-lens 3.8.3 → 3.8.5

package/index.ts

@@ -1013,106 +1013,123 @@ export default function (pi: ExtensionAPI) {
 				dbg("session_start: no project rules found");
 			}
 
-			const todoResult = todoScanner.scanDirectory(cwd);
-			dbg(
-				`session_start TODO scan: ${todoResult.items.length} items (baseline stored)`,
-			);
-			cacheManager.writeCache(
-				"todo-baseline",
-				{ items: todoResult.items },
-				cwd,
-			);
+			// Fire-and-forget background cache warming — none of these add to `parts`
+			Promise.resolve()
+				.then(async () => {
+					// TODO baseline
+					const todoResult = todoScanner.scanDirectory(cwd);
+					dbg(
+						`session_start TODO scan: ${todoResult.items.length} items (baseline stored)`,
+					);
+					cacheManager.writeCache(
+						"todo-baseline",
+						{ items: todoResult.items },
+						cwd,
+					);
 
-			// Heavy startup scans — gated on project root + file count safety check
-			if (!startupScan.canWarmCaches) {
-				dbg(
-					`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`,
-				);
-			} else {
-				// Dead code scan — use cache if fresh (cached for on-demand reporting)
-				if (await knipClient.ensureAvailable()) {
-					const cached = cacheManager.readCache<
-						ReturnType<KnipClient["analyze"]>
-					>("knip", cwd);
-					if (cached) {
+					// Heavy startup scans — gated on project root + file count safety check
+					if (!startupScan.canWarmCaches) {
 						dbg(
-							`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`,
+							`session_start: skipping heavy scans (${startupScan.reason ?? "unknown"})`,
 						);
-					} else {
-						const startMs = Date.now();
-						const knipResult = knipClient.analyze(cwd);
-						cacheManager.writeCache("knip", knipResult, cwd, {
-							scanDurationMs: Date.now() - startMs,
-						});
-						dbg(`session_start Knip scan done`);
+						return;
 					}
-				} else {
-					dbg(`session_start Knip: not available`);
-				}
 
-				// Duplicate code detection — use cache if fresh, auto-install if needed (cached for on-demand reporting)
-				if (await jscpdClient.ensureAvailable()) {
-					const cached = cacheManager.readCache<
-						ReturnType<JscpdClient["scan"]>
-					>("jscpd", cwd);
-					if (cached) {
-						dbg(`session_start jscpd: cache hit`);
+					// Dead code scan — use cache if fresh (cached for on-demand reporting)
+					if (await knipClient.ensureAvailable()) {
+						const cached = cacheManager.readCache<
+							ReturnType<KnipClient["analyze"]>
+						>("knip", cwd);
+						if (cached) {
+							dbg(
+								`session_start Knip: cache hit (${Math.round((Date.now() - new Date(cached.meta.timestamp).getTime()) / 1000)}s ago)`,
+							);
+						} else {
+							const startMs = Date.now();
+							const knipResult = knipClient.analyze(cwd);
+							cacheManager.writeCache("knip", knipResult, cwd, {
+								scanDurationMs: Date.now() - startMs,
+							});
+							dbg(`session_start Knip scan done`);
+						}
 					} else {
-						const startMs = Date.now();
-						const jscpdResult = jscpdClient.scan(cwd);
-						cacheManager.writeCache("jscpd", jscpdResult, cwd, {
-							scanDurationMs: Date.now() - startMs,
-						});
-						dbg(`session_start jscpd scan done`);
+						dbg(`session_start Knip: not available`);
 					}
-				} else {
-					dbg(`session_start jscpd: not available`);
-				}
-
-				// Type-coverage runs on-demand via /lens-booboo only (not at session_start)
-
-				// Scan for exported functions (cached for duplicate detection on write)
-				if (await astGrepClient.ensureAvailable()) {
-					const exports = await astGrepClient.scanExports(cwd, "typescript");
-					dbg(`session_start exports scan: ${exports.size} functions found`);
-					for (const [name, file] of exports) {
-						cachedExports.set(name, file);
-					}
-				}
 
-				// Build similarity index for pre-write structural duplicate detection.
-				try {
-					const existing = await loadIndex(scanRoot);
-					if (
-						existing &&
-						existing.entries.size > 0 &&
-						(await isIndexFresh(scanRoot))
-					) {
-						cachedProjectIndex = existing;
-						dbg(
-							`session_start: loaded fresh project index (${existing.entries.size} entries)`,
-						);
-					} else {
-						const sourceFiles = getSourceFiles(scanRoot, true);
-						const tsFiles = sourceFiles.filter(
-							(f) => f.endsWith(".ts") || f.endsWith(".tsx"),
-						);
-						if (tsFiles.length > 0 && tsFiles.length <= 500) {
-							cachedProjectIndex = await buildProjectIndex(scanRoot, tsFiles);
-							await saveIndex(cachedProjectIndex, scanRoot);
-							dbg(
-								`session_start: built project index (${cachedProjectIndex.entries.size} entries from ${tsFiles.length} files)`,
-							);
+					// Duplicate code detection — use cache if fresh, auto-install if needed (cached for on-demand reporting)
+					if (await jscpdClient.ensureAvailable()) {
+						const cached = cacheManager.readCache<
+							ReturnType<JscpdClient["scan"]>
+						>("jscpd", cwd);
+						if (cached) {
+							dbg(`session_start jscpd: cache hit`);
 						} else {
-							dbg(
-								`session_start: skipped project index (${tsFiles.length} files)`,
-							);
+							const startMs = Date.now();
+							const jscpdResult = jscpdClient.scan(cwd);
+							cacheManager.writeCache("jscpd", jscpdResult, cwd, {
+								scanDurationMs: Date.now() - startMs,
+							});
+							dbg(`session_start jscpd scan done`);
 						}
+					} else {
+						dbg(`session_start jscpd: not available`);
 					}
-				} catch (err) {
-					dbg(`session_start: project index build failed: ${err}`);
-				}
-			} // end canWarmCaches
+
+					// Type-coverage runs on-demand via /lens-booboo only (not at session_start)
+
+					// Parallelize: exports scan + project index load (independent operations)
+					const [exportsResult, indexResult] = await Promise.allSettled([
+						// Scan for exported functions (cached for duplicate detection on write)
+						astGrepClient.ensureAvailable().then(async (available) => {
+							if (!available) {
+								dbg(`session_start ast-grep: not available`);
+								return;
+							}
+							const exports = await astGrepClient.scanExports(cwd, "typescript");
+							dbg(`session_start exports scan: ${exports.size} functions found`);
+							for (const [name, file] of exports) {
+								cachedExports.set(name, file);
+							}
+						}),
+						// Build similarity index for pre-write structural duplicate detection
+						(async () => {
+							const existing = await loadIndex(scanRoot);
+							if (
+								existing &&
+								existing.entries.size > 0 &&
+								(await isIndexFresh(scanRoot))
+							) {
+								cachedProjectIndex = existing;
+								dbg(
+									`session_start: loaded fresh project index (${existing.entries.size} entries)`,
+								);
+							} else {
+								const sourceFiles = getSourceFiles(scanRoot, true);
+								const tsFiles = sourceFiles.filter(
+									(f) => f.endsWith(".ts") || f.endsWith(".tsx"),
+								);
+								if (tsFiles.length > 0 && tsFiles.length <= 500) {
+									cachedProjectIndex = await buildProjectIndex(scanRoot, tsFiles);
+									await saveIndex(cachedProjectIndex, scanRoot);
+									dbg(
+										`session_start: built project index (${cachedProjectIndex.entries.size} entries from ${tsFiles.length} files)`,
+									);
+								} else {
+									dbg(
+										`session_start: skipped project index (${tsFiles.length} files)`,
+									);
+								}
+							}
+						})(),
+					]);
+					if (exportsResult.status === "rejected")
+						dbg(`session_start: exports scan failed: ${exportsResult.reason}`);
+					if (indexResult.status === "rejected")
+						dbg(`session_start: project index build failed: ${indexResult.reason}`);
+
+					dbg(`session_start: background cache warming complete`);
+				})
+				.catch((err) => dbg(`session_start: background warm error: ${err}`));
 
 			dbg(
 				`session_start: scans complete (${parts.length} part(s)), cached for commands`,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.8.3",
+	"version": "3.8.5",
 	"type": "module",
 	"description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
 	"repository": {
@@ -20,6 +20,7 @@
 		"rust:test": "cargo test --manifest-path rust/Cargo.toml --all-targets --all-features",
 		"rust:build": "cargo build --manifest-path rust/Cargo.toml --release",
 		"rust:build:debug": "cargo build --manifest-path rust/Cargo.toml",
+		"check": "node scripts/check-extensions.mjs",
 		"download-grammars": "node scripts/download-grammars.js",
 		"postinstall": "node scripts/download-grammars.js"
 	},
@@ -47,6 +48,7 @@
 		"rules/",
 		"skills/",
 		"scripts/download-grammars.js",
+		"scripts/check-extensions.mjs",
 		"rust/src/",
 		"rust/Cargo.toml",
 		"default-architect.yaml",
@@ -67,6 +69,7 @@
 	"dependencies": {
 		"@sinclair/typebox": "^0.34.0",
 		"cross-spawn": "^7.0.6",
+		"typescript": "^5.0.0",
 		"vscode-jsonrpc": "^8.2.1"
 	},
 	"optionalDependencies": {

package/scripts/check-extensions.mjs

@@ -0,0 +1,87 @@
+/**
+ * Verifies all relative imports in the published package resolve to real files.
+ * Catches "Cannot find module" errors from missing files in the npm tarball.
+ *
+ * Usage:
+ *   node scripts/check-extensions.mjs           # from source (uses npm pack --dry-run)
+ *   node scripts/check-extensions.mjs <dir>     # from installed location
+ */
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { execSync } from "node:child_process";
+
+const installDir = resolve(process.argv[2] ?? ".");
+const fromSource = process.argv[2] == null;
+
+function getFiles() {
+  if (fromSource) {
+    // Use npm pack --dry-run to get exactly the files that would be published
+    const out = execSync("npm pack --dry-run 2>&1", { encoding: "utf8" });
+    return out
+      .split("\n")
+      .map(l => l.match(/npm notice [\d.]+\w+\s+(.+)/)?.[1]?.trim())
+      .filter(f => f && (f.endsWith(".ts") || f.endsWith(".mjs")))
+      .map(f => join(installDir, f));
+  }
+  // Installed location: walk all .ts/.mjs files
+  const files = [];
+  function walk(dir) {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      if (entry === "node_modules") continue;
+      if (statSync(full).isDirectory()) walk(full);
+      else if (entry.endsWith(".ts") || entry.endsWith(".mjs")) files.push(full);
+    }
+  }
+  walk(installDir);
+  return files;
+}
+
+function resolveImport(fromFile, importPath) {
+  const base = join(dirname(fromFile), importPath);
+  for (const candidate of [
+    base,
+    base.replace(/\.js$/, ".ts"),   // .js → .ts (TypeScript ESM convention)
+    base + ".ts",
+    join(base, "index.ts"),
+  ]) {
+    try { if (statSync(candidate).isFile()) return candidate; } catch {}
+  }
+  return null;
+}
+
+const files = getFiles();
+console.log(`Checking ${files.length} file(s) in: ${installDir}\n`);
+
+let totalImports = 0;
+let failed = 0;
+const seen = new Set();
+
+for (const file of files) {
+  const src = readFileSync(file, "utf8");
+  const relFile = file.slice(installDir.length + 1).replace(/\\/g, "/");
+  // Strip comments before matching imports
+  const stripped = src.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const importRe = /from\s+['"](\.[^'"]+)['"]/g;
+  let match;
+  while ((match = importRe.exec(stripped)) !== null) {
+    const importPath = match[1];
+    const key = `${relFile}:${importPath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    totalImports++;
+    if (!resolveImport(file, importPath)) {
+      console.error(`  ✗ ${relFile}`);
+      console.error(`      imports '${importPath}' → NOT FOUND`);
+      failed++;
+    }
+  }
+}
+
+console.log(`Checked ${totalImports} relative import(s) across ${files.length} file(s).`);
+console.log(failed === 0
+  ? `\nAll imports resolve OK ✓`
+  : `\n${failed} import(s) could not be resolved ✗`);
+
+process.exit(failed > 0 ? 1 : 0);