pi-lens 2.2.9 → 3.0.0

package/clients/dispatch/runners/pyright.ts

@@ -7,58 +7,17 @@
  * 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";
+import { ensureTool } from "../../installer/index.js";
+import { safeSpawn } from "../../safe-spawn.js";
 import type {
 	Diagnostic,
 	DispatchContext,
 	RunnerDefinition,
 	RunnerResult,
 } from "../types.js";
+import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 
-// Cache pyright availability check
-let pyrightAvailable: boolean | null = null;
-let pyrightCommand: string | null = null;
-
-/**
- * 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;
-
-	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 pyright = createAvailabilityChecker("pyright", ".exe");
 
 const pyrightRunner: RunnerDefinition = {
 	id: "pyright",
@@ -67,17 +26,24 @@ const pyrightRunner: RunnerDefinition = {
 	enabledByDefault: true,
 
 	async run(ctx: DispatchContext): Promise<RunnerResult> {
-		// 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",
-			timeout: 60000,
-			shell: true,
-		});
+		const result = safeSpawn(
+			pyright.getCommand()!,
+			["--outputjson", ctx.filePath],
+			{
+				timeout: 60000,
+			},
+		);
 
 		// Pyright returns non-zero when errors found, that's OK
 		if (result.error) {
@@ -102,53 +68,44 @@ const pyrightRunner: RunnerDefinition = {
 			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),
+			};
 		}
 	},
 };
 
-interface PyrightDiagnostic {
-	file: string;
-	severity: "error" | "warning" | "information";
-	message: string;
-	range: {
-		start: { line: number; character: number };
-		end: { line: number; character: number };
-	};
-	rule: string;
-}
+function parsePyrightOutput(data: any, _filePath: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
 
-interface PyrightResult {
-	generalDiagnostics: PyrightDiagnostic[];
-}
+	// 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
 
-function parsePyrightOutput(
-	data: PyrightResult,
-	filePath: string,
-): Diagnostic[] {
-	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",
+		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: d.rule,
-			fixable: false, // Pyright can't auto-fix, only suggest
-		}));
+			rule: diag.rule,
+		});
+	}
+
+	return diagnostics;
 }
 
 export default pyrightRunner;

package/clients/dispatch/runners/python-slop.js

@@ -0,0 +1,97 @@
+/**
+ * Python Slop runner for dispatch system
+ *
+ * Detects "slop" patterns in Python code:
+ * - Verbose patterns (ceremony that adds no value)
+ * - Defensive over-checking (excessive guards)
+ * - Manual reimplementation of builtins
+ * - Unnecessary object allocations
+ *
+ * Based on slop-code-bench: https://github.com/SprocketLab/slop-code-bench
+ */
+import { safeSpawn } from "../../safe-spawn.js";
+import { createConfigFinder, isSgAvailable, } from "./utils/runner-helpers.js";
+const findSlopConfig = createConfigFinder("python-slop-rules");
+const pythonSlopRunner = {
+    id: "python-slop",
+    appliesTo: ["python"],
+    priority: 25, // Between pyright (5) and ruff (10)
+    enabledByDefault: true,
+    skipTestFiles: true, // Slop rules can be noisy in test files
+    async run(ctx) {
+        // Check if ast-grep is available
+        if (!isSgAvailable()) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Find slop config
+        const configPath = findSlopConfig(ctx.cwd);
+        if (!configPath) {
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
+        // Run ast-grep scan
+        const args = ["sg", "scan", "--config", configPath, "--json", ctx.filePath];
+        const result = safeSpawn("npx", args, {
+            timeout: 30000,
+        });
+        const raw = result.stdout + result.stderr;
+        if (result.status === 0 && !raw.trim()) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        // Parse results
+        const diagnostics = parseSlopOutput(raw, ctx.filePath);
+        if (diagnostics.length === 0) {
+            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        }
+        return {
+            status: "failed",
+            diagnostics,
+            semantic: "warning",
+        };
+    },
+};
+function parseSlopOutput(raw, filePath) {
+    const diagnostics = [];
+    try {
+        // Try to parse as JSON first
+        const data = JSON.parse(raw);
+        const items = Array.isArray(data) ? data : [data];
+        for (const item of items) {
+            const rule = item.rule || "slop";
+            const message = item.message || "Pattern detected";
+            const severity = item.severity || "warning";
+            diagnostics.push({
+                id: `python-slop-${rule}`,
+                message,
+                filePath,
+                line: item.start?.line || 0,
+                column: item.start?.column || 0,
+                severity: severity === "error" ? "error" : "warning",
+                semantic: severity === "error" ? "blocking" : "warning",
+                tool: "python-slop",
+                rule,
+            });
+        }
+    }
+    catch {
+        // Not JSON, try line-by-line parsing
+        const lines = raw.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+            // Try to extract line numbers from typical output formats
+            const match = line.match(/:(\d+):/);
+            if (match) {
+                diagnostics.push({
+                    id: "python-slop-pattern",
+                    message: line.trim(),
+                    filePath,
+                    line: parseInt(match[1], 10),
+                    column: 0,
+                    severity: "warning",
+                    semantic: "warning",
+                    tool: "python-slop",
+                });
+            }
+        }
+    }
+    return diagnostics;
+}
+export default pythonSlopRunner;

package/clients/dispatch/runners/python-slop.test.js

@@ -0,0 +1,203 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+function createMockContext(filePath) {
+    return {
+        filePath,
+        cwd: process.cwd(),
+        kind: "python",
+        autofix: false,
+        deltaMode: false,
+        baselines: { get: () => [], add: () => { }, save: () => { } },
+        pi: {},
+        hasTool: async () => false,
+        log: () => { },
+    };
+}
+// Helper for safe file cleanup
+function safeUnlink(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Ignore cleanup errors on Windows
+    }
+}
+describe("python-slop runner", () => {
+    const require = createRequire(import.meta.url);
+    it("should have correct runner definition", async () => {
+        const slopModule = await import("./python-slop.js");
+        const runner = slopModule.default;
+        expect(runner.id).toBe("python-slop");
+        expect(runner.appliesTo).toEqual(["python"]);
+        expect(runner.priority).toBe(25);
+        expect(runner.enabledByDefault).toBe(true);
+        expect(runner.skipTestFiles).toBe(true);
+    });
+    it("should detect ast-grep availability", () => {
+        const { spawnSync } = require("node:child_process");
+        const result = spawnSync("npx", ["sg", "--version"], {
+            encoding: "utf-8",
+            timeout: 10000,
+            shell: true,
+        });
+        expect(result.error || result.status !== 0 ? "not available" : "available").toBe("available");
+    });
+    it("should detect verbose range-len pattern", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_range_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: using range(len()) instead of enumerate
+def process_items(items):
+    for i in range(len(items)):
+        print(items[i])
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                d.message.includes("range(len") &&
+                d.message.includes("enumerate"))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect manual min/max pattern", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_minmax_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: manual min/max instead of built-in
+def find_max(a, b):
+    if a > b:
+        m = a
+    else:
+        m = b
+    return m
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                (d.message.includes("min") || d.message.includes("max")))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect defensive None guard", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_guard_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: defensive None guard
+def process(data):
+    if data is None:
+        return None
+    return data.upper()
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                (d.message.includes("defensive") ||
+                    d.message.includes("guard")))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect list comprehension ceremony", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_list_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: redundant list comprehension
+def convert(items):
+    return [x for x in items]
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                d.message.includes("list") &&
+                d.message.includes("unnecessary"))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should detect chained comparison opportunity", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_chain_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Slop: could use chained comparison
+def check_range(x, a, b):
+    return a < x and x < b
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            expect(result.diagnostics.some((d) => d.tool === "python-slop" &&
+                d.message.includes("chained"))).toBe(true);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should pass clean Python files", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_ok_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Clean Python code
+def process_items(items):
+    """Process items using proper Python idioms."""
+    for i, item in enumerate(items):
+        print(f"{i}: {item}")
+
+def find_max(a, b):
+    return max(a, b)
+
+def check_range(x, min_val, max_val):
+    return min_val < x < max_val
+
+def convert(items):
+    return list(items)
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // Should have no slop issues
+            const slopIssues = result.diagnostics.filter((d) => d.tool === "python-slop");
+            expect(slopIssues.length).toBe(0);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+    it("should categorize by weight correctly", async () => {
+        const tmpFile = path.join(process.env.TEMP || "/tmp", `slop_test_weight_${Date.now()}.py`);
+        fs.writeFileSync(tmpFile, `# Multiple slop patterns - weight 3 and weight 4
+def bad_code(items):
+    # Weight 3: range(len)
+    for i in range(len(items)):
+        print(items[i])
+    
+    # Weight 3: redundant list comprehension  
+    return [x for x in items]
+`);
+        try {
+            const slopModule = await import("./python-slop.js");
+            const runner = slopModule.default;
+            const result = await runner.run(createMockContext(tmpFile));
+            // Should detect at least the range(len) pattern
+            expect(result.diagnostics.length).toBeGreaterThanOrEqual(1);
+            // All should be warnings (weight 3)
+            const warnings = result.diagnostics.filter((d) => d.severity === "warning");
+            expect(warnings.length).toBeGreaterThanOrEqual(1);
+        }
+        finally {
+            safeUnlink(tmpFile);
+        }
+    });
+});