pi-lens 3.7.1 → 3.8.2

package/clients/installer/index.ts

@@ -281,6 +281,16 @@ async function verifyToolBinary(binPath: string): Promise<boolean> {
 /**
  * Install an npm package tool
  */
+/**
+ * Packages that require postinstall scripts to download native binaries.
+ * All others get --ignore-scripts to prevent arbitrary code execution during install.
+ */
+const NEEDS_POSTINSTALL = new Set([
+	"@biomejs/biome",
+	"@ast-grep/napi",
+	"esbuild",
+]);
+
 async function installNpmTool(
 	packageName: string,
 	binaryName: string,
@@ -311,7 +321,15 @@ async function installNpmTool(
 			: isWindows
 				? "npm.cmd"
 				: "npm";
-		const proc = spawn(pm, ["install", packageName], {
+		// Use --ignore-scripts unless the package explicitly needs postinstall
+		// (e.g. biome downloads a platform-specific native binary via postinstall).
+		const needsScripts = NEEDS_POSTINSTALL.has(
+			packageName.split("@")[0] ?? packageName,
+		);
+		const installArgs = needsScripts
+			? ["install", packageName]
+			: ["install", "--ignore-scripts", packageName];
+		const proc = spawn(pm, installArgs, {
 			cwd: TOOLS_DIR,
 			stdio: ["ignore", "pipe", "pipe"],
 			shell: isWindows, // Required for .cmd files on Windows

package/clients/lsp/index.ts

@@ -8,7 +8,6 @@
  * - Resource cleanup
  */
 
-import { Effect } from "effect";
 import type { LSPClientInfo } from "./client.js";
 import { createLSPClient } from "./client.js";
 import { getServersForFileWithConfig } from "./config.js";
@@ -339,45 +338,6 @@ export class LSPService {
 	}
 }
 
-// --- Effect Integration ---
-
-/**
- * Effect wrapper for LSP operations
- */
-export function lspEffect(service: LSPService) {
-	return {
-		openFile: (filePath: string, content: string) =>
-			Effect.tryPromise({
-				try: () => service.openFile(filePath, content),
-				catch: (err) => err as Error,
-			}),
-
-		updateFile: (filePath: string, content: string) =>
-			Effect.tryPromise({
-				try: () => service.updateFile(filePath, content),
-				catch: (err) => err as Error,
-			}),
-
-		getDiagnostics: (filePath: string) =>
-			Effect.tryPromise({
-				try: () => service.getDiagnostics(filePath),
-				catch: (err) => err as Error,
-			}),
-
-		hasLSP: (filePath: string) =>
-			Effect.tryPromise({
-				try: () => service.hasLSP(filePath),
-				catch: (err) => err as Error,
-			}),
-
-		shutdown: () =>
-			Effect.tryPromise({
-				try: () => service.shutdown(),
-				catch: (err) => err as Error,
-			}),
-	};
-}
-
 // --- Singleton Instance ---
 
 let globalLSPService: LSPService | null = null;

package/clients/lsp/launch.ts

@@ -328,7 +328,8 @@ export async function launchViaPackageManager(
 	// For npx on Windows, use shell mode with the full command string
 	if (isWin) {
 		const argsStr = args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ");
-		const shellCommand = `npx -y ${packageName}${argsStr ? ` ${argsStr}` : ""}`;
+		// --no prevents silent download of uncached packages
+		const shellCommand = `npx --no ${packageName}${argsStr ? ` ${argsStr}` : ""}`;
 
 		const cwd = String(options.cwd ?? process.cwd());
 		const env = { ...process.env, ...options.env };
@@ -393,7 +394,9 @@ export async function launchViaPackageManager(
 		};
 	}
 
-	return launchLSP("npx", ["-y", packageName, ...args], options);
+	// --no prevents silent download of uncached packages; user must have
+	// already installed the LSP server via the interactive-install flow.
+	return launchLSP("npx", ["--no", packageName, ...args], options);
 }
 
 /**

package/clients/package-root.ts

@@ -0,0 +1,44 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRootCache = new Map<string, string>();
+
+/**
+ * Resolve the installed package root for the current module.
+ * Walks upward from the caller until it finds the nearest package.json.
+ *
+ * This is the correct alternative to process.cwd() for resolving
+ * pi-lens's own assets (rules, grammars, configs) when installed
+ * globally — cwd is the user's project, not the extension root.
+ *
+ * Credit: alexx-ftw (PR #1)
+ */
+export function getPackageRoot(importMetaUrl: string): string {
+	const cached = packageRootCache.get(importMetaUrl);
+	if (cached) return cached;
+
+	let current = path.dirname(fileURLToPath(importMetaUrl));
+	while (true) {
+		if (fs.existsSync(path.join(current, "package.json"))) {
+			packageRootCache.set(importMetaUrl, current);
+			return current;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) {
+			packageRootCache.set(importMetaUrl, current);
+			return current;
+		}
+		current = parent;
+	}
+}
+
+/**
+ * Resolve a path relative to the installed package root.
+ */
+export function resolvePackagePath(
+	importMetaUrl: string,
+	...segments: string[]
+): string {
+	return path.join(getPackageRoot(importMetaUrl), ...segments);
+}

package/clients/pipeline.ts

@@ -5,7 +5,7 @@
  * Runs sequentially on every file write/edit:
  *   1. Secrets scan (blocking — early exit)
  *   2. Auto-format (Biome, Prettier, Ruff, gofmt, etc.)
- *   3. Auto-fix (Biome --write, Ruff --fix)
+ *   3. Auto-fix (Biome --write, Ruff --fix, ESLint --fix)
  *   4. LSP file sync (open/update in LSP servers)
  *   5. Dispatch lint (type errors, security rules)
  *   6. Test runner (run corresponding test file)
@@ -17,11 +17,13 @@ import * as path from "node:path";
 import type { BiomeClient } from "./biome-client.js";
 import { dispatchLintWithResult } from "./dispatch/integration.js";
 import type { PiAgentAPI } from "./dispatch/types.js";
+import { detectFileKind, getFileKindLabel } from "./file-kinds.js";
 import type { FormatService } from "./format-service.js";
 import { logLatency } from "./latency-logger.js";
 import { getLSPService } from "./lsp/index.js";
 import type { MetricsClient } from "./metrics-client.js";
 import type { RuffClient } from "./ruff-client.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
 import { formatSecrets, scanForSecrets } from "./secrets-scanner.js";
 import type { TestRunnerClient } from "./test-runner-client.js";
 
@@ -49,6 +51,12 @@ export interface PipelineDeps {
 export interface PipelineResult {
 	/** Text to append to tool_result content */
 	output: string;
+	/**
+	 * Cascade diagnostics (errors in OTHER files caused by this edit).
+	 * Intentionally NOT included in output — surfaced at turn_end instead
+	 * so mid-refactor intermediate errors don't derail the agent.
+	 */
+	cascadeOutput?: string;
 	/** True if secrets found — block the agent */
 	isError: boolean;
 	/** True if file was modified by format/autofix */
@@ -90,6 +98,109 @@ function createPhaseTracker(toolName: string, filePath: string): PhaseTracker {
 	};
 }
 
+// --- ESLint autofix helpers ---
+
+const ESLINT_CONFIGS = [
+	".eslintrc",
+	".eslintrc.js",
+	".eslintrc.cjs",
+	".eslintrc.json",
+	".eslintrc.yaml",
+	".eslintrc.yml",
+	"eslint.config.js",
+	"eslint.config.mjs",
+	"eslint.config.cjs",
+];
+
+const JSTS_EXTS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]);
+
+function isJsTs(filePath: string): boolean {
+	return JSTS_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+function hasEslintConfig(cwd: string): boolean {
+	for (const cfg of ESLINT_CONFIGS) {
+		if (nodeFs.existsSync(path.join(cwd, cfg))) return true;
+	}
+	try {
+		const pkg = JSON.parse(
+			nodeFs.readFileSync(path.join(cwd, "package.json"), "utf-8"),
+		);
+		if (pkg.eslintConfig) return true;
+	} catch {}
+	return false;
+}
+
+let _eslintAvailable: boolean | null = null;
+let _eslintBin: string | null = null;
+
+function findEslintBin(cwd: string): string {
+	const isWin = process.platform === "win32";
+	const local = path.join(
+		cwd,
+		"node_modules",
+		".bin",
+		isWin ? "eslint.cmd" : "eslint",
+	);
+	if (nodeFs.existsSync(local)) return local;
+	return "eslint";
+}
+
+/**
+ * Run eslint --fix on a file. Returns number of fixable issues resolved,
+ * or 0 if ESLint is not configured / not available.
+ */
+async function tryEslintFix(filePath: string, cwd: string): Promise<number> {
+	if (!hasEslintConfig(cwd)) return 0;
+	if (_eslintAvailable === false) return 0;
+	if (_eslintAvailable === null) {
+		const candidate = findEslintBin(cwd);
+		const check = await safeSpawnAsync(candidate, ["--version"], {
+			timeout: 5000,
+			cwd,
+		});
+		_eslintAvailable = !check.error && check.status === 0;
+		if (_eslintAvailable) _eslintBin = candidate;
+	}
+	if (!_eslintAvailable || !_eslintBin) return 0;
+	const cmd = _eslintBin;
+	// --fix-dry-run returns JSON with fixable counts without writing to disk.
+	// Use it to get the real count, then apply with --fix only if needed.
+	const dry = await safeSpawnAsync(
+		cmd,
+		[
+			"--fix-dry-run",
+			"--format",
+			"json",
+			"--no-error-on-unmatched-pattern",
+			filePath,
+		],
+		{ timeout: 30000, cwd },
+	);
+	if (dry.status === 2) return 0;
+	let fixableCount = 0;
+	try {
+		const results: Array<{
+			fixableErrorCount?: number;
+			fixableWarningCount?: number;
+		}> = JSON.parse(dry.stdout);
+		fixableCount = results.reduce(
+			(sum, r) =>
+				sum + (r.fixableErrorCount ?? 0) + (r.fixableWarningCount ?? 0),
+			0,
+		);
+	} catch {}
+	if (fixableCount === 0) return 0;
+	// Apply the fixes
+	const fix = await safeSpawnAsync(
+		cmd,
+		["--fix", "--no-error-on-unmatched-pattern", filePath],
+		{ timeout: 30000, cwd },
+	);
+	if (fix.status === 2) return 0;
+	return fixableCount;
+}
+
 // --- Main Pipeline ---
 
 export async function runPipeline(
@@ -184,6 +295,9 @@ export async function runPipeline(
 	}
 
 	let output = "";
+	const autofixTools: string[] = []; // track which tools fixed something
+	let testSummary: { passed: number; total: number; failed: number } | null =
+		null;
 
 	// --- 4. Auto-fix ---
 	// Biome (TS/JS) and Ruff (Python) never touch the same file, so their
@@ -208,6 +322,7 @@ export async function runPipeline(
 			const result = ruffClient.fixFile(filePath);
 			if (result.success && result.fixed > 0) {
 				fixedCount += result.fixed;
+				autofixTools.push(`ruff:${result.fixed}`);
 				fixedThisTurn.add(filePath);
 				dbg(`autofix: ruff fixed ${result.fixed} issue(s) in ${filePath}`);
 			}
@@ -217,12 +332,24 @@ export async function runPipeline(
 			const result = biomeClient.fixFile(filePath);
 			if (result.success && result.fixed > 0) {
 				fixedCount += result.fixed;
+				autofixTools.push(`biome:${result.fixed}`);
 				fixedThisTurn.add(filePath);
 				dbg(`autofix: biome fixed ${result.fixed} issue(s) in ${filePath}`);
 			}
 		}
 	}
-	phase.end("autofix", { fixedCount, tools: ["ruff", "biome"] });
+	// ESLint --fix: only for jsts files in projects that use ESLint
+	if (!noAutofix && isJsTs(filePath)) {
+		const eslintFixed = await tryEslintFix(filePath, cwd);
+		if (eslintFixed > 0) {
+			fixedCount += eslintFixed;
+			autofixTools.push(`eslint:${eslintFixed}`);
+			fixedThisTurn.add(filePath);
+			dbg(`autofix: eslint fixed ${eslintFixed} issue(s) in ${filePath}`);
+		}
+	}
+
+	phase.end("autofix", { fixedCount, tools: ["ruff", "biome", "eslint"] });
 
 	// --- 5. Dispatch lint ---
 	phase.start("dispatch_lint");
@@ -239,7 +366,9 @@ export async function runPipeline(
 	}
 
 	if (fixedCount > 0) {
-		output += `\n\n✅ Auto-fixed ${fixedCount} issue(s) in ${path.basename(filePath)}`;
+		const detail =
+			autofixTools.length > 0 ? ` (${autofixTools.join(", ")})` : "";
+		output += `\n\n✅ Auto-fixed ${fixedCount} issue(s)${detail}`;
 	}
 
 	if (formatChanged || fixedCount > 0) {
@@ -285,6 +414,11 @@ export async function runPipeline(
 					},
 				});
 				if (testResult && !testResult.error) {
+					testSummary = {
+						passed: testResult.passed,
+						total: testResult.passed + testResult.failed + testResult.skipped,
+						failed: testResult.failed,
+					};
 					const testOutput = testRunnerClient.formatResult(testResult);
 					if (testOutput) {
 						output += `\n\n${testOutput}`;
@@ -296,6 +430,11 @@ export async function runPipeline(
 	phase.end("test_runner", { found: testInfoFound, ran: testRunnerRan });
 
 	// --- 7. Cascade diagnostics (LSP only) ---
+	// Deferred: cascade errors are errors in OTHER files caused by this edit.
+	// They are NOT shown inline (mid-refactor they are always noisy — agent is
+	// still editing the other files). Returned in cascadeOutput so index.ts can
+	// surface the LAST snapshot at turn_end once all edits in the turn are done.
+	let cascadeOutput: string | undefined;
 	if (getFlag("lens-lsp") && !getFlag("no-lsp")) {
 		const MAX_CASCADE_FILES = 5;
 		const MAX_DIAGNOSTICS_PER_FILE = 20;
@@ -319,7 +458,7 @@ export async function runPipeline(
 			}
 
 			if (otherFileErrors.length > 0) {
-				output += `\n\n📐 Cascade errors detected in ${otherFileErrors.length} other file(s):`;
+				let c = `📐 Cascade errors in ${otherFileErrors.length} other file(s) — fix before finishing turn:`;
 				for (const { file, errors } of otherFileErrors.slice(
 					0,
 					MAX_CASCADE_FILES,
@@ -329,18 +468,19 @@ export async function runPipeline(
 						errors.length > MAX_DIAGNOSTICS_PER_FILE
 							? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more`
 							: "";
-					output += `\n<diagnostics file="${file}">`;
+					c += `\n<diagnostics file="${file}">`;
 					for (const e of limited) {
 						const line = (e.range?.start?.line ?? 0) + 1;
 						const col = (e.range?.start?.character ?? 0) + 1;
 						const code = e.code ? ` [${e.code}]` : "";
-						output += `\n  ${code} (${line}:${col}) ${e.message.split("\n")[0].slice(0, 100)}`;
+						c += `\n  ${code} (${line}:${col}) ${e.message.split("\n")[0].slice(0, 100)}`;
 					}
-					output += `${suffix}\n</diagnostics>`;
+					c += `${suffix}\n</diagnostics>`;
 				}
 				if (otherFileErrors.length > MAX_CASCADE_FILES) {
-					output += `\n... and ${otherFileErrors.length - MAX_CASCADE_FILES} more files with errors`;
+					c += `\n... and ${otherFileErrors.length - MAX_CASCADE_FILES} more files with errors`;
 				}
+				cascadeOutput = c;
 			}
 
 			logLatency({
@@ -358,6 +498,36 @@ export async function runPipeline(
 
 	// --- Final timing ---
 	const elapsed = Date.now() - pipelineStart;
+
+	// --- All-clear / warnings notice ---
+	// When no blocking output exists, emit a one-liner so the agent knows
+	// checks actually ran and what the result was.
+	if (!output) {
+		const kind = detectFileKind(filePath);
+		const langLabel = kind ? getFileKindLabel(kind) : path.extname(filePath);
+		const parts: string[] = [];
+
+		if (dispatchResult.warnings.length > 0) {
+			// Has non-blocking warnings — tell agent to run booboo
+			parts.push(`no blockers`);
+			parts.push(
+				`${dispatchResult.warnings.length} warning(s) -> /lens-booboo`,
+			);
+		} else if (kind) {
+			parts.push(`${langLabel} clean`);
+		}
+
+		if (testSummary) {
+			if (testSummary.failed === 0) {
+				parts.push(`${testSummary.passed}/${testSummary.total} tests`);
+			}
+			// failing tests already have their own output above — skip here
+		}
+
+		parts.push(`${elapsed}ms`);
+		output = `checkmark ${parts.join(" · ")}`.replace("checkmark", "\u2713");
+	}
+
 	phase.end("total", { hasOutput: !!output });
 
 	logLatency({
@@ -370,6 +540,7 @@ export async function runPipeline(
 
 	return {
 		output,
+		cascadeOutput,
 		isError: false,
 		fileModified: formatChanged || fixedCount > 0,
 	};

package/clients/scan-utils.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { EXCLUDED_DIRS, isTestFile } from "./file-utils.js";
+import { collectSourceFiles, isBuildArtifact } from "./source-filter.js";
 
 /**
  * Common parsing logic for ast-grep JSON output (handles both array and NDJSON).
@@ -27,6 +28,10 @@ export function parseAstGrepJson(raw: string): any[] {
 
 /**
  * Check if a file should be ignored based on project type and common patterns.
+ *
+ * @deprecated Use `isBuildArtifact()` from `source-filter.js` instead for artifact
+ * detection, or compose your own filter using `collectSourceFiles()`. This function
+ * is kept for backward compatibility.
  */
 export function shouldIgnoreFile(
 	filePath: string,
@@ -35,7 +40,10 @@ export function shouldIgnoreFile(
 	const relPath = filePath.replace(/\\/g, "/");
 	const _basename = path.basename(relPath);
 
-	// Ignore compiled JS in TS projects
+	// Use new source-filter module for artifact detection
+	if (isTsProject && isBuildArtifact(filePath)) return true;
+
+	// Legacy: simple JS check for non-TS projects (hand-written JS)
 	const isJs =
 		relPath.endsWith(".js") ||
 		relPath.endsWith(".mjs") ||
@@ -53,36 +61,16 @@ export function shouldIgnoreFile(
 
 /**
  * Recursively find source files in a directory, respecting common excludes.
+ *
+ * This function now delegates to `collectSourceFiles()` from the `source-filter`
+ * module for unified artifact detection across all scanners.
+ *
+ * @param dir - Directory to scan
+ * @param isTsProject - Deprecated parameter (kept for backward compatibility, not used)
+ * @returns Array of absolute file paths that are source files (not build artifacts)
  */
-export function getSourceFiles(dir: string, isTsProject: boolean): string[] {
-	const files: string[] = [];
-	if (!fs.existsSync(dir)) return files;
-
-	const scan = (d: string) => {
-		let entries: fs.Dirent[] = [];
-		try {
-			entries = fs.readdirSync(d, { withFileTypes: true });
-		} catch {
-			return;
-		}
-
-		for (const entry of entries) {
-			const full = path.join(d, entry.name);
-			if (entry.isDirectory()) {
-				if (EXCLUDED_DIRS.includes(entry.name)) continue;
-				scan(full);
-			} else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name)) {
-				// Skip compiled JS if it's a TS project
-				if (
-					isTsProject &&
-					entry.name.endsWith(".js") &&
-					fs.existsSync(full.replace(/\.js$/, ".ts"))
-				)
-					continue;
-				files.push(full);
-			}
-		}
-	};
-	scan(dir);
-	return files;
+export function getSourceFiles(dir: string, _isTsProject?: boolean): string[] {
+	// Delegate to the unified source-filter module
+	// isTsProject parameter is no longer needed — artifact detection is automatic
+	return collectSourceFiles(dir);
 }

package/clients/sg-runner.ts

@@ -9,6 +9,10 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import {
+	getSgCommand,
+	isSgAvailable,
+} from "./dispatch/runners/utils/runner-helpers.js";
 import { safeSpawn } from "./safe-spawn.js";
 
 /**
@@ -90,10 +94,7 @@ export class SgRunner {
 	isAvailable(): boolean {
 		if (this.available !== null) return this.available;
 
-		const result = safeSpawn("npx", ["sg", "--version"], {
-			timeout: 10000,
-		});
-		this.available = !result.error && result.status === 0;
+		this.available = isSgAvailable();
 		return this.available;
 	}
 
@@ -214,7 +215,8 @@ export class SgRunner {
 	 * Run ast-grep synchronously (for simple scans)
 	 */
 	execSync(args: string[]): { output: string; error?: string } {
-		const result = safeSpawn("npx", ["sg", ...args], {
+		const { cmd: sgCmd, args: sgPre } = getSgCommand();
+		const result = safeSpawn(sgCmd, [...sgPre, "sg", ...args], {
 			timeout: 30000,
 		});