pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/oxlint.test.ts

@@ -0,0 +1,303 @@
+/**
+ * Tests for oxlint runner
+ */
+
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import type { DispatchContext } from "../types.js";
+
+/**
+ * Delay helper for Windows file cleanup
+ * Windows may hold file handles briefly after process exit
+ */
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function createMockContext(
+	filePath: string,
+	overrides: Partial<DispatchContext> = {},
+): DispatchContext {
+	return {
+		filePath,
+		cwd: process.cwd(),
+		kind: "jsts" as any,
+		autofix: false,
+		deltaMode: false,
+		baselines: { get: () => [], add: () => {}, save: () => {} } as any,
+		pi: { getFlag: () => false, ...overrides.pi },
+		hasTool: async () => false,
+		log: () => {},
+		...overrides,
+	};
+}
+
+describe("oxlint runner", () => {
+	const require = createRequire(import.meta.url);
+
+	it("should have correct runner definition", async () => {
+		const oxlintModule = await import("./oxlint.js");
+		const runner = oxlintModule.default;
+
+		expect(runner.id).toBe("oxlint");
+		expect(runner.appliesTo).toEqual(["jsts"]);
+		expect(runner.priority).toBe(12);
+		expect(runner.enabledByDefault).toBe(false); // Opt-in initially
+		expect(runner.skipTestFiles).toBe(true);
+	});
+
+	it("should detect oxlint availability", () => {
+		const { spawnSync } =
+			require("node:child_process") as typeof import("node:child_process");
+		const result = spawnSync("oxlint", ["--version"], {
+			encoding: "utf-8",
+			timeout: 10000,
+			shell: true,
+		});
+		expect(
+			result.error || result.status !== 0 ? "not available" : "available",
+		).toBeTruthy(); // May or may not be installed
+	});
+
+	it("should detect common lint issues", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_test_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Test file with issues
+function test() {
+	// Double negation
+	const flag = !!value;
+	
+	// Unused variable
+	const unused = 42;
+	
+	// Console statement
+	console.log("test");
+}
+`,
+		);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// If oxlint is installed, should detect issues
+			// If not installed, will be skipped
+			if (result.status !== "skipped") {
+				// Should detect at least some issues (console, unused vars, etc.)
+				expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+				expect(
+					result.diagnostics.some(
+						(d) =>
+							d.tool === "oxlint" &&
+							(d.message.includes("console") ||
+								d.message.includes("unused") ||
+								d.message.includes("!!")),
+					),
+				).toBe(true);
+			}
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should respect no-oxlint flag", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_flag_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`function test() { console.log("test"); }`,
+		);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+
+			// Create context with no-oxlint flag set to true
+			const ctxWithFlag = createMockContext(tmpFile, {
+				pi: { getFlag: (name: string) => name === "no-oxlint" },
+			});
+
+			const result = await runner.run(ctxWithFlag);
+			expect(result.status).toBe("skipped");
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should provide fix suggestions when available", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_fix_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// File with auto-fixable issues
+const x = !!value;
+`,
+		);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (result.status !== "skipped" && result.diagnostics.length > 0) {
+				// Some issues should be fixable
+				const fixableDiags = result.diagnostics.filter((d) => d.fixable);
+				// At least some diagnostics should have fixes
+				expect(fixableDiags.length).toBeGreaterThanOrEqual(0);
+			}
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should pass clean TypeScript files", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_ok_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`// Clean TypeScript file
+function greet(name: string): string {
+	return \`Hello, \${name}!\`;
+}
+
+const result = greet("world");
+export { greet };
+`,
+		);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (result.status !== "skipped") {
+				// Clean files should have no issues
+				expect(result.diagnostics.length).toBe(0);
+				expect(result.status).toBe("succeeded");
+			}
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should handle JSON output correctly", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_json_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(
+			tmpFile,
+			`const unused = 1;`,
+		);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (result.status !== "skipped") {
+				// All diagnostics should have required fields
+				for (const diag of result.diagnostics) {
+					expect(diag.id).toBeDefined();
+					expect(diag.message).toBeDefined();
+					expect(diag.tool).toBe("oxlint");
+					expect(diag.line).toBeGreaterThanOrEqual(1);
+					expect(diag.severity).toMatch(/^(error|warning|info)$/);
+				}
+			}
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should skip when oxlint is not available", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_skip_${Date.now()}.ts`,
+		);
+		fs.writeFileSync(tmpFile, `const x = 1;`);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+
+			// Check if oxlint is available
+			const { spawnSync } =
+				require("node:child_process") as typeof import("node:child_process");
+			const checkResult = spawnSync("oxlint", ["--version"], {
+				encoding: "utf-8",
+				timeout: 5000,
+				shell: true,
+			});
+
+			const isAvailable = !checkResult.error && checkResult.status === 0;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			if (!isAvailable) {
+				expect(result.status).toBe("skipped");
+				expect(result.diagnostics).toHaveLength(0);
+			}
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+
+	it("should handle parsing errors gracefully", async () => {
+		const tmpFile = path.join(
+			process.env.TEMP || "/tmp",
+			`oxlint_parse_${Date.now()}.ts`,
+		);
+		// Intentionally malformed file
+		fs.writeFileSync(tmpFile, `const x = `);
+
+		try {
+			const oxlintModule = await import("./oxlint.js");
+			const runner = oxlintModule.default;
+			const result = await runner.run(createMockContext(tmpFile));
+
+			// Should handle parse errors without crashing
+			expect(["succeeded", "failed", "skipped"]).toContain(result.status);
+		} finally {
+			// Windows may hold file handles briefly - add small delay
+			await delay(100);
+			if (fs.existsSync(tmpFile)) {
+				fs.unlinkSync(tmpFile);
+			}
+		}
+	});
+});

package/clients/dispatch/runners/oxlint.ts

@@ -0,0 +1,175 @@
+/**
+ * Oxlint runner for dispatch system
+ *
+ * Fast Rust-based JavaScript/TypeScript linter from the Oxc project.
+ * Zero-config by default, compatible with ESLint rules.
+ *
+ * Why oxlint?
+ * - ~100x faster than ESLint (Rust-based)
+ * - Zero-config (works out of the box)
+ * - Growing rule set (eslint, typescript, react, unicorn, etc.)
+ * - JSON output for programmatic use
+ *
+ * Comparison:
+ * - vs Biome: Similar performance, different rule philosophy
+ * - vs ESLint: Much faster, fewer rules but catching up
+ *
+ * Install: npm install -D oxlint
+ * Or: cargo install oxlint
+ *
+ * Config: .oxlintrc.json (optional, zero-config works)
+ */
+
+import { safeSpawn } from "../../safe-spawn.js";
+import { createAvailabilityChecker, createConfigFinder } from "./utils/runner-helpers.js";
+import type {
+	Diagnostic,
+	DispatchContext,
+	RunnerDefinition,
+	RunnerResult,
+} from "../types.js";
+
+const oxlint = createAvailabilityChecker("oxlint", ".exe");
+const findOxlintConfig = createConfigFinder(".oxlintrc.json");
+
+/**
+ * Parse oxlint JSON output
+ *
+ * Format: Array of diagnostic objects
+ * [{
+ *   "ruleId": "no-unused-vars",
+ *   "severity": 2,
+ *   "message": "'foo' is assigned a value but never used.",
+ *   "line": 10,
+ *   "column": 7,
+ *   "nodeType": "Identifier",
+ *   "messageId": "unusedVar",
+ *   "endLine": 10,
+ *   "endColumn": 10,
+ *   "fix": { "range": [95, 108], "text": "" }
+ * }]
+ */
+function parseOxlintOutput(raw: string, filePath: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
+
+	if (!raw.trim()) {
+		return diagnostics;
+	}
+
+	try {
+		const parsed = JSON.parse(raw) as Array<{
+			ruleId?: string;
+			severity?: number; // 1 = warning, 2 = error
+			message?: string;
+			line?: number;
+			column?: number;
+			messageId?: string;
+			fix?: { range: number[]; text: string };
+		}>;
+
+		if (!Array.isArray(parsed)) {
+			return diagnostics;
+		}
+
+		for (const item of parsed) {
+			if (!item.message || !item.line) continue;
+
+			const severity = item.severity === 2 ? "error" : "warning";
+
+			diagnostics.push({
+				id: `oxlint-${item.line}-${item.ruleId || "unknown"}`,
+				message: item.message,
+				filePath,
+				line: item.line,
+				column: item.column || 1,
+				severity,
+				semantic: severity === "error" ? "blocking" : "warning",
+				tool: "oxlint",
+				rule: item.ruleId,
+				fixable: !!item.fix,
+				fixSuggestion: item.fix?.text,
+			});
+		}
+	} catch {
+		// If JSON parsing fails, try line-based parsing for CLI output
+		const lines = raw.split("\n").filter((l) => l.trim());
+		for (const line of lines) {
+			// Try to match: file.ts:10:7: Error message [ruleId]
+			const match = line.match(/^(\d+):(\d+)\s+(.+?)\s*\[(\w+)\]$/);
+			if (match) {
+				diagnostics.push({
+					id: `oxlint-${match[1]}-${match[4]}`,
+					message: `${match[4]}: ${match[3]}`,
+					filePath,
+					line: parseInt(match[1], 10),
+					column: parseInt(match[2], 10),
+					severity: "warning",
+					semantic: "warning",
+					tool: "oxlint",
+					rule: match[4],
+				});
+			}
+		}
+	}
+
+	return diagnostics;
+}
+
+const oxlintRunner: RunnerDefinition = {
+	id: "oxlint",
+	appliesTo: ["jsts"],
+	priority: 12, // Between biome (10) and slop (25)
+	enabledByDefault: false, // Opt-in initially - let users choose between biome/oxlint
+	skipTestFiles: true, // Test files often use patterns that trigger false positives
+
+	async run(ctx: DispatchContext): Promise<RunnerResult> {
+		// Skip if oxlint is not installed
+		if (!oxlint.isAvailable(ctx.cwd || process.cwd())) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Check if user explicitly disabled oxlint (keep biome as primary)
+		if (ctx.pi.getFlag("no-oxlint")) {
+			return { status: "skipped", diagnostics: [], semantic: "none" };
+		}
+
+		// Build args
+		// --format json: JSON output
+		// --config: Only if config file exists (zero-config otherwise)
+		const args: string[] = ["--format", "json"];
+
+		// Check for config file
+		const configPath = findOxlintConfig(ctx.cwd);
+		if (configPath) {
+			args.push("--config", configPath);
+		}
+
+		// Add file path
+		args.push(ctx.filePath);
+
+		const result = safeSpawn(oxlint.getCommand()!, args, {
+			timeout: 10000, // Fast - should complete quickly
+		});
+
+		// oxlint exits with code 1 if issues found, 0 if clean
+		if (result.status === 0 && !result.stdout?.trim()) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		// Parse diagnostics
+		const raw = result.stdout + result.stderr;
+		const diagnostics = parseOxlintOutput(raw, ctx.filePath);
+
+		if (diagnostics.length === 0) {
+			return { status: "succeeded", diagnostics: [], semantic: "none" };
+		}
+
+		return {
+			status: "failed",
+			diagnostics,
+			semantic: "warning",
+		};
+	},
+};
+
+export default oxlintRunner;

package/clients/dispatch/runners/pyright.js

@@ -6,62 +6,27 @@
  *
  * 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;
-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;
-    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;
-}
+import { ensureTool } from "../../installer/index.js";
+import { safeSpawn } from "../../safe-spawn.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+const pyright = createAvailabilityChecker("pyright", ".exe");
 const pyrightRunner = {
     id: "pyright",
     appliesTo: ["python"],
     priority: 5, // Higher priority than ruff (10) - type errors are more important
     enabledByDefault: true,
     async run(ctx) {
-        // Skip if pyright is not installed
-        if (!isPyrightAvailable(ctx.cwd || process.cwd())) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
+        const cwd = ctx.cwd || process.cwd();
+        // Auto-install pyright if not available (it's one of the 4 auto-install tools)
+        if (!pyright.isAvailable(cwd)) {
+            const installed = await ensureTool("pyright");
+            if (!installed) {
+                return { status: "skipped", diagnostics: [], semantic: "none" };
+            }
         }
         // Run pyright with JSON output (use venv-local or global command)
-        const result = spawnSync(pyrightCommand, ["--outputjson", ctx.filePath], {
-            encoding: "utf-8",
+        const result = safeSpawn(pyright.getCommand(), ["--outputjson", ctx.filePath], {
             timeout: 60000,
-            shell: true,
         });
         // Pyright returns non-zero when errors found, that's OK
         if (result.error) {
@@ -81,34 +46,39 @@ const pyrightRunner = {
             return {
                 status: hasErrors ? "failed" : "succeeded",
                 diagnostics,
-                semantic: "warning",
+                semantic: hasErrors ? "blocking" : "warning",
             };
         }
         catch {
-            // JSON parse failed, skip
-            return { status: "skipped", diagnostics: [], semantic: "none" };
+            // JSON parse error
+            return {
+                status: "failed",
+                diagnostics: [],
+                semantic: "none",
+                rawOutput: output.slice(0, 500),
+            };
         }
     },
 };
-function parsePyrightOutput(data, filePath) {
-    if (!data.generalDiagnostics)
-        return [];
-    return data.generalDiagnostics
-        .filter((d) => {
-        // Only include errors and warnings, skip informational
-        return d.severity === "error" || d.severity === "warning";
-    })
-        .map((d) => ({
-        id: `pyright-${d.range.start.line}-${d.rule}`,
-        message: d.message.split("\n")[0], // First line only (pyright has multi-line messages)
-        filePath,
-        line: d.range.start.line + 1, // Pyright is 0-indexed, we're 1-indexed
-        column: d.range.start.character + 1,
-        severity: d.severity === "error" ? "error" : "warning",
-        semantic: d.severity === "error" ? "blocking" : "warning",
-        tool: "pyright",
-        rule: d.rule,
-        fixable: false, // Pyright can't auto-fix, only suggest
-    }));
+function parsePyrightOutput(data, _filePath) {
+    const diagnostics = [];
+    // Pyright JSON output has generalDiagnostics array
+    const generalDiags = data.generalDiagnostics || [];
+    for (const diag of generalDiags) {
+        // Skip if not for this file (pyright may output diagnostics for imports)
+        // For now, include all - caller will filter if needed
+        diagnostics.push({
+            id: `pyright-${diag.rule || diag.start?.line || "unknown"}`,
+            message: diag.message || "Type error",
+            filePath: diag.file || _filePath,
+            line: diag.start?.line || 0,
+            column: diag.start?.column || 0,
+            severity: diag.severity === "error" ? "error" : "warning",
+            semantic: diag.severity === "error" ? "blocking" : "warning",
+            tool: "pyright",
+            rule: diag.rule,
+        });
+    }
+    return diagnostics;
 }
 export default pyrightRunner;

package/clients/dispatch/runners/pyright.test.js

@@ -55,7 +55,14 @@ greet(123)
             expect(result.diagnostics.some((d) => d.severity === "error")).toBe(true);
         }
         finally {
-            fs.unlinkSync(tmpFile);
+            try {
+                if (fs.existsSync(tmpFile)) {
+                    fs.unlinkSync(tmpFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
         }
     });
     it("should pass valid Python files", async () => {
@@ -78,7 +85,14 @@ greet("world")
             expect(result.diagnostics.length).toBe(0);
         }
         finally {
-            fs.unlinkSync(tmpFile);
+            try {
+                if (fs.existsSync(tmpFile)) {
+                    fs.unlinkSync(tmpFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
         }
     });
 });

package/clients/dispatch/runners/pyright.test.ts

@@ -72,7 +72,13 @@ greet(123)
 			expect(result.diagnostics.some((d) => d.tool === "pyright")).toBe(true);
 			expect(result.diagnostics.some((d) => d.severity === "error")).toBe(true);
 		} finally {
-			fs.unlinkSync(tmpFile);
+			try {
+				if (fs.existsSync(tmpFile)) {
+					fs.unlinkSync(tmpFile);
+				}
+			} catch {
+				// Ignore cleanup errors
+			}
 		}
 	});
 
@@ -103,7 +109,13 @@ greet("world")
 			expect(result.status).toBe("succeeded");
 			expect(result.diagnostics.length).toBe(0);
 		} finally {
-			fs.unlinkSync(tmpFile);
+			try {
+				if (fs.existsSync(tmpFile)) {
+					fs.unlinkSync(tmpFile);
+				}
+			} catch {
+				// Ignore cleanup errors
+			}
 		}
 	});
 });