pi-lens 2.2.2 → 2.2.4

package/clients/dispatch/dispatcher.js

@@ -13,6 +13,7 @@
  * - OutputSemantic: How to display (blocking, warning, silent, etc.)
  * - BaselineStore: Track pre-existing issues for delta mode
  */
+import * as fs from "node:fs";
 import { detectFileKind } from "../file-kinds.js";
 // --- In-Memory Baseline Store ---
 export function createBaselineStore() {
@@ -31,6 +32,8 @@ export function createBaselineStore() {
 }
 // --- Runner Registry ---
 const globalRegistry = new Map();
+// Track last-run mtime per file+runner to skip unchanged files
+const lastRunMtimes = new Map(); // key: `${runnerId}:${filePath}` -> mtimeMs
 export function registerRunner(runner) {
     if (globalRegistry.has(runner.id)) {
         console.error(`[dispatch] Duplicate runner: ${runner.id}`);
@@ -41,17 +44,31 @@ export function registerRunner(runner) {
 export function getRunner(id) {
     return globalRegistry.get(id);
 }
-export function getRunnersForKind(kind) {
+export function getRunnersForKind(kind, filePath) {
     if (!kind)
         return [];
     const runners = [];
+    const isTestFile = filePath ? isTest(filePath) : false;
     for (const runner of globalRegistry.values()) {
+        // Skip runners that shouldn't run on test files
+        if (isTestFile && runner.skipTestFiles)
+            continue;
         if (runner.appliesTo.includes(kind) || runner.appliesTo.length === 0) {
             runners.push(runner);
         }
     }
     return runners.sort((a, b) => a.priority - b.priority);
 }
+function isTest(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    return (normalized.includes(".test.") ||
+        normalized.includes(".spec.") ||
+        normalized.includes("/test/") ||
+        normalized.includes("/tests/") ||
+        normalized.includes("__tests__/") ||
+        normalized.includes("test-utils") ||
+        normalized.startsWith("test-"));
+}
 export function listRunners() {
     return Array.from(globalRegistry.values());
 }
@@ -206,6 +223,22 @@ export async function dispatchForFile(ctx, groups) {
 }
 // --- Run Single Runner ---
 async function runRunner(ctx, runner, defaultSemantic) {
+    // Skip if file unchanged (optimization for expensive runners)
+    if (runner.skipIfUnchanged) {
+        const cacheKey = `${runner.id}:${ctx.filePath}`;
+        try {
+            const stats = fs.statSync(ctx.filePath);
+            const lastMtime = lastRunMtimes.get(cacheKey);
+            if (lastMtime && stats.mtimeMs <= lastMtime) {
+                return { status: "skipped", diagnostics: [], semantic: "none" };
+            }
+            // Update mtime after run (below)
+            lastRunMtimes.set(cacheKey, stats.mtimeMs);
+        }
+        catch {
+            // File doesn't exist or stat failed, continue with run
+        }
+    }
     try {
         const result = await runner.run(ctx);
         return {

package/clients/dispatch/dispatcher.ts

@@ -14,6 +14,7 @@
  * - BaselineStore: Track pre-existing issues for delta mode
  */
 
+import * as fs from "node:fs";
 import type { FileKind } from "../file-kinds.js";
 import { detectFileKind } from "../file-kinds.js";
 
@@ -51,6 +52,9 @@ export function createBaselineStore(): BaselineStore {
 
 const globalRegistry = new Map<string, RunnerDefinition>();
 
+// Track last-run mtime per file+runner to skip unchanged files
+const lastRunMtimes = new Map<string, number>(); // key: `${runnerId}:${filePath}` -> mtimeMs
+
 export function registerRunner(runner: RunnerDefinition): void {
 	if (globalRegistry.has(runner.id)) {
 		console.error(`[dispatch] Duplicate runner: ${runner.id}`);
@@ -65,10 +69,16 @@ export function getRunner(id: string): RunnerDefinition | undefined {
 
 export function getRunnersForKind(
 	kind: FileKind | undefined,
+	filePath?: string,
 ): RunnerDefinition[] {
 	if (!kind) return [];
 	const runners: RunnerDefinition[] = [];
+	const isTestFile = filePath ? isTest(filePath) : false;
+
 	for (const runner of globalRegistry.values()) {
+		// Skip runners that shouldn't run on test files
+		if (isTestFile && runner.skipTestFiles) continue;
+
 		if (runner.appliesTo.includes(kind) || runner.appliesTo.length === 0) {
 			runners.push(runner);
 		}
@@ -76,6 +86,19 @@ export function getRunnersForKind(
 	return runners.sort((a, b) => a.priority - b.priority);
 }
 
+function isTest(filePath: string): boolean {
+	const normalized = filePath.replace(/\\/g, "/");
+	return (
+		normalized.includes(".test.") ||
+		normalized.includes(".spec.") ||
+		normalized.includes("/test/") ||
+		normalized.includes("/tests/") ||
+		normalized.includes("__tests__/") ||
+		normalized.includes("test-utils") ||
+		normalized.startsWith("test-")
+	);
+}
+
 export function listRunners(): RunnerDefinition[] {
 	return Array.from(globalRegistry.values());
 }
@@ -288,6 +311,22 @@ async function runRunner(
 	runner: RunnerDefinition,
 	defaultSemantic: OutputSemantic,
 ): Promise<RunnerResult> {
+	// Skip if file unchanged (optimization for expensive runners)
+	if (runner.skipIfUnchanged) {
+		const cacheKey = `${runner.id}:${ctx.filePath}`;
+		try {
+			const stats = fs.statSync(ctx.filePath);
+			const lastMtime = lastRunMtimes.get(cacheKey);
+			if (lastMtime && stats.mtimeMs <= lastMtime) {
+				return { status: "skipped", diagnostics: [], semantic: "none" };
+			}
+			// Update mtime after run (below)
+			lastRunMtimes.set(cacheKey, stats.mtimeMs);
+		} catch {
+			// File doesn't exist or stat failed, continue with run
+		}
+	}
+
 	try {
 		const result = await runner.run(ctx);
 		return {

package/clients/dispatch/runners/ast-grep.js

@@ -13,6 +13,7 @@ const astGrepRunner = {
     appliesTo: ["jsts", "python", "go", "rust", "cxx"],
     priority: 30,
     enabledByDefault: false,
+    skipTestFiles: true, // Many rules are noisy in tests
     async run(ctx) {
         // Check if ast-grep is available
         const check = spawnSync("sg", ["--version"], {

package/clients/dispatch/runners/ast-grep.ts

@@ -21,6 +21,7 @@ const astGrepRunner: RunnerDefinition = {
 	appliesTo: ["jsts", "python", "go", "rust", "cxx"],
 	priority: 30,
 	enabledByDefault: false,
+	skipTestFiles: true, // Many rules are noisy in tests
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Check if ast-grep is available

package/clients/dispatch/runners/pyright.js

@@ -7,18 +7,44 @@
  * Requires: pyright (pip install pyright or npm install -g pyright)
  */
 import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 // Cache pyright availability check
 let pyrightAvailable = null;
-function isPyrightAvailable() {
+let pyrightCommand = null;
+/**
+ * Find pyright command, checking venv first, then global.
+ * Looks in .venv/bin, venv/bin (Unix), .venv/Scripts, venv/Scripts (Windows)
+ */
+function findPyrightCommand(cwd) {
+    // Check common venv locations
+    const venvPaths = [
+        ".venv/bin/pyright",
+        "venv/bin/pyright",
+        ".venv/Scripts/pyright.exe",
+        "venv/Scripts/pyright.exe",
+    ];
+    for (const venvPath of venvPaths) {
+        const fullPath = path.join(cwd, venvPath);
+        if (fs.existsSync(fullPath)) {
+            return `"${fullPath}"`; // Quote for Windows paths with spaces
+        }
+    }
+    // Fall back to global
+    return "pyright";
+}
+function isPyrightAvailable(cwd) {
     if (pyrightAvailable !== null)
         return pyrightAvailable;
-    // Check if pyright CLI is available (do NOT auto-install via npx)
-    const check = spawnSync("pyright", ["--version"], {
+    const command = findPyrightCommand(cwd || process.cwd());
+    const check = spawnSync(command, ["--version"], {
         encoding: "utf-8",
         timeout: 5000,
         shell: true,
     });
     pyrightAvailable = !check.error && check.status === 0;
+    if (pyrightAvailable)
+        pyrightCommand = command;
     return pyrightAvailable;
 }
 const pyrightRunner = {
@@ -28,11 +54,11 @@ const pyrightRunner = {
     enabledByDefault: true,
     async run(ctx) {
         // Skip if pyright is not installed
-        if (!isPyrightAvailable()) {
+        if (!isPyrightAvailable(ctx.cwd || process.cwd())) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        // Run pyright with JSON output (use direct command, not npx)
-        const result = spawnSync("pyright", ["--outputjson", ctx.filePath], {
+        // Run pyright with JSON output (use venv-local or global command)
+        const result = spawnSync(pyrightCommand, ["--outputjson", ctx.filePath], {
             encoding: "utf-8",
             timeout: 60000,
             shell: true,

package/clients/dispatch/runners/pyright.ts

@@ -8,6 +8,8 @@
  */
 
 import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type {
 	Diagnostic,
 	DispatchContext,
@@ -17,17 +19,44 @@ import type {
 
 // Cache pyright availability check
 let pyrightAvailable: boolean | null = null;
+let pyrightCommand: string | null = null;
 
-function isPyrightAvailable(): boolean {
+/**
+ * Find pyright command, checking venv first, then global.
+ * Looks in .venv/bin, venv/bin (Unix), .venv/Scripts, venv/Scripts (Windows)
+ */
+function findPyrightCommand(cwd: string): string {
+	// Check common venv locations
+	const venvPaths = [
+		".venv/bin/pyright",
+		"venv/bin/pyright",
+		".venv/Scripts/pyright.exe",
+		"venv/Scripts/pyright.exe",
+	];
+
+	for (const venvPath of venvPaths) {
+		const fullPath = path.join(cwd, venvPath);
+		if (fs.existsSync(fullPath)) {
+			return `"${fullPath}"`; // Quote for Windows paths with spaces
+		}
+	}
+
+	// Fall back to global
+	return "pyright";
+}
+
+function isPyrightAvailable(cwd?: string): boolean {
 	if (pyrightAvailable !== null) return pyrightAvailable;
 
-	// Check if pyright CLI is available (do NOT auto-install via npx)
-	const check = spawnSync("pyright", ["--version"], {
+	const command = findPyrightCommand(cwd || process.cwd());
+
+	const check = spawnSync(command, ["--version"], {
 		encoding: "utf-8",
 		timeout: 5000,
 		shell: true,
 	});
 	pyrightAvailable = !check.error && check.status === 0;
+	if (pyrightAvailable) pyrightCommand = command;
 	return pyrightAvailable;
 }
 
@@ -39,12 +68,12 @@ const pyrightRunner: RunnerDefinition = {
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Skip if pyright is not installed
-		if (!isPyrightAvailable()) {
+		if (!isPyrightAvailable(ctx.cwd || process.cwd())) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
-		// Run pyright with JSON output (use direct command, not npx)
-		const result = spawnSync("pyright", ["--outputjson", ctx.filePath], {
+		// Run pyright with JSON output (use venv-local or global command)
+		const result = spawnSync(pyrightCommand!, ["--outputjson", ctx.filePath], {
 			encoding: "utf-8",
 			timeout: 60000,
 			shell: true,

package/clients/dispatch/runners/ruff.js

@@ -2,29 +2,62 @@
  * Ruff runner for dispatch system
  *
  * Ruff handles both formatting and linting for Python files.
+ * Supports venv-local installations.
  */
 import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { stripAnsi } from "../../sanitize.js";
+// Cache ruff availability check
+let ruffAvailable = null;
+let ruffCommand = null;
+/**
+ * Find ruff command, checking venv first, then global.
+ */
+function findRuffCommand(cwd) {
+    const venvPaths = [
+        ".venv/bin/ruff",
+        "venv/bin/ruff",
+        ".venv/Scripts/ruff.exe",
+        "venv/Scripts/ruff.exe",
+    ];
+    for (const venvPath of venvPaths) {
+        const fullPath = path.join(cwd, venvPath);
+        if (fs.existsSync(fullPath)) {
+            return `"${fullPath}"`;
+        }
+    }
+    return "ruff";
+}
+function isRuffAvailable(cwd) {
+    if (ruffAvailable !== null)
+        return ruffAvailable;
+    const command = findRuffCommand(cwd || process.cwd());
+    const check = spawnSync(command, ["--version"], {
+        encoding: "utf-8",
+        timeout: 5000,
+        shell: true,
+    });
+    ruffAvailable = !check.error && check.status === 0;
+    if (ruffAvailable)
+        ruffCommand = command;
+    return ruffAvailable;
+}
 const ruffRunner = {
     id: "ruff-lint",
     appliesTo: ["python"],
     priority: 10,
     enabledByDefault: true,
     async run(ctx) {
-        // Check if ruff is available
-        const check = spawnSync("ruff", ["--version"], {
-            encoding: "utf-8",
-            timeout: 5000,
-            shell: true,
-        });
-        if (check.error || check.status !== 0) {
+        // Skip if ruff is not installed
+        if (!isRuffAvailable(ctx.cwd || process.cwd())) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         // Run ruff check
         const args = ctx.autofix
             ? ["check", "--fix", ctx.filePath]
             : ["check", ctx.filePath];
-        const result = spawnSync("ruff", args, {
+        const result = spawnSync(ruffCommand, args, {
             encoding: "utf-8",
             timeout: 30000,
             shell: true,

package/clients/dispatch/runners/ruff.ts

@@ -2,9 +2,12 @@
  * Ruff runner for dispatch system
  *
  * Ruff handles both formatting and linting for Python files.
+ * Supports venv-local installations.
  */
 
 import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { stripAnsi } from "../../sanitize.js";
 import type {
 	Diagnostic,
@@ -13,6 +16,46 @@ import type {
 	RunnerResult,
 } from "../types.js";
 
+// Cache ruff availability check
+let ruffAvailable: boolean | null = null;
+let ruffCommand: string | null = null;
+
+/**
+ * Find ruff command, checking venv first, then global.
+ */
+function findRuffCommand(cwd: string): string {
+	const venvPaths = [
+		".venv/bin/ruff",
+		"venv/bin/ruff",
+		".venv/Scripts/ruff.exe",
+		"venv/Scripts/ruff.exe",
+	];
+
+	for (const venvPath of venvPaths) {
+		const fullPath = path.join(cwd, venvPath);
+		if (fs.existsSync(fullPath)) {
+			return `"${fullPath}"`;
+		}
+	}
+
+	return "ruff";
+}
+
+function isRuffAvailable(cwd?: string): boolean {
+	if (ruffAvailable !== null) return ruffAvailable;
+
+	const command = findRuffCommand(cwd || process.cwd());
+	const check = spawnSync(command, ["--version"], {
+		encoding: "utf-8",
+		timeout: 5000,
+		shell: true,
+	});
+
+	ruffAvailable = !check.error && check.status === 0;
+	if (ruffAvailable) ruffCommand = command;
+	return ruffAvailable;
+}
+
 const ruffRunner: RunnerDefinition = {
 	id: "ruff-lint",
 	appliesTo: ["python"],
@@ -20,14 +63,8 @@ const ruffRunner: RunnerDefinition = {
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// Check if ruff is available
-		const check = spawnSync("ruff", ["--version"], {
-			encoding: "utf-8",
-			timeout: 5000,
-			shell: true,
-		});
-
-		if (check.error || check.status !== 0) {
+		// Skip if ruff is not installed
+		if (!isRuffAvailable(ctx.cwd || process.cwd())) {
 			return { status: "skipped", diagnostics: [], semantic: "none" };
 		}
 
@@ -36,7 +73,7 @@ const ruffRunner: RunnerDefinition = {
 			? ["check", "--fix", ctx.filePath]
 			: ["check", ctx.filePath];
 
-		const result = spawnSync("ruff", args, {
+		const result = spawnSync(ruffCommand!, args, {
 			encoding: "utf-8",
 			timeout: 30000,
 			shell: true,

package/clients/dispatch/runners/type-safety.js

@@ -12,6 +12,7 @@ const typeSafetyRunner = {
     appliesTo: ["jsts"],
     priority: 20,
     enabledByDefault: true,
+    skipIfUnchanged: true, // Skip type-coverage if file unchanged
     async run(ctx) {
         // Only check TypeScript files
         if (!ctx.filePath.match(/\.tsx?$/)) {

package/clients/dispatch/runners/type-safety.ts

@@ -20,6 +20,7 @@ const typeSafetyRunner: RunnerDefinition = {
 	appliesTo: ["jsts"],
 	priority: 20,
 	enabledByDefault: true,
+	skipIfUnchanged: true, // Skip type-coverage if file unchanged
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
 		// Only check TypeScript files

package/clients/dispatch/types.ts

@@ -96,6 +96,10 @@ export interface RunnerDefinition {
 	appliesTo: readonly FileKind[];
 	priority: number;
 	enabledByDefault: boolean;
+	/** Skip this runner for test files (false positive reduction) */
+	skipTestFiles?: boolean;
+	/** Skip if file unchanged since last run (check mtime) */
+	skipIfUnchanged?: boolean;
 	/** Check if runner should run */
 	when?: (ctx: DispatchContext) => Promise<boolean> | boolean;
 	/** Execute the runner */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "2.2.2",
+	"version": "2.2.4",
 	"type": "module",
 	"description": "Real-time code quality feedback for pi — TypeScript LSP, Biome, ast-grep, Ruff, complexity metrics, duplicate detection. Includes automated fix loop (/lens-booboo-fix) and interactive architectural refactoring (/lens-booboo-refactor) with browser-based interviews.",
 	"repository": {